diff --git a/clients/backup/bolt.go b/clients/backup/bolt.go new file mode 100644 index 00000000..9be91e99 --- /dev/null +++ b/clients/backup/bolt.go @@ -0,0 +1,349 @@ +package backup + +import ( + "encoding/json" + "errors" + "fmt" + "time" + + "github.com/gogo/protobuf/proto" + "github.com/influxdata/influx-cli/v2/api" + "github.com/influxdata/influx-cli/v2/clients/backup/internal" + "go.etcd.io/bbolt" +) + +//go:generate protoc --gogo_out=. internal/meta.proto + +// NOTE: An unfortunate naming collision below. Bolt calls its databases "buckets". +// These are the names that were used in the metadata DB for 2.0.x versions of influxdb. +var ( + bucketsBoltBucket = []byte("bucketsv1") + organizationsBoltBucket = []byte("organizationsv1") + v1MetadataBoltBucket = []byte("v1_tsm1_metadata") + v1MetadataBoltKey = []byte("meta.db") +) + +// influxdbBucketSchema models the JSON structure used by InfluxDB 2.0.x to serialize +// bucket metadata in the embedded KV store. +type influxdbBucketSchema struct { + ID string `json:"id"` + OrgID string `json:"orgID"` + Type int `json:"type"` + Name string `json:"name"` + Description *string `json:"description,omitempty"` + RetentionPeriod time.Duration `json:"retentionPeriod"` + ShardGroupDuration time.Duration `json:"ShardGroupDuration"` +} + +// influxdbOrganizationSchema models the JSON structure used by InfluxDB 2.0.x to serialize +// organization metadata in the embedded KV store. +type influxdbOrganizationSchema struct { + ID string `json:"id"` + Name string `json:"name"` +} + +// influxdbV1DatabaseInfo models the protobuf structure used by InfluxDB 2.0.x to serialize +// database info in the embedded KV store. +type influxdbV1DatabaseInfo struct { + Name string + DefaultRetentionPolicy string + RetentionPolicies []influxdbV1RetentionPolicyInfo +} + +// influxdbV1RetentionPolicyInfo models the protobuf structure used by InfluxDB 2.0.x to serialize +// retention-policy info in the embedded KV store. +type influxdbV1RetentionPolicyInfo struct { + Name string + ReplicaN int32 + Duration int64 + ShardGroupDuration int64 + ShardGroups []influxdbV1ShardGroupInfo + Subscriptions []influxdbV1SubscriptionInfo +} + +// influxdbV1ShardGroupInfo models the protobuf structure used by InfluxDB 2.0.x to serialize +// shard-group info in the embedded KV store. +type influxdbV1ShardGroupInfo struct { + ID int64 + StartTime time.Time + EndTime time.Time + DeletedAt time.Time + Shards []influxdbV1ShardInfo + TruncatedAt time.Time +} + +// influxdbV1ShardInfo models the protobuf structure used by InfluxDB 2.0.x to serialize +// shard info in the embedded KV store. +type influxdbV1ShardInfo struct { + ID int64 + Owners []influxdbV1ShardOwnerInfo +} + +// inflxudbV1ShardOwnerInfo models the protobuf structure used by InfluxDB 2.0.x to serialize +// shard-owner info in the embedded KV store. +type influxdbV1ShardOwnerInfo struct { + NodeID int64 +} + +// influxdbV1SubscriptionInfo models the protobuf structure used by InfluxDB 2.0.x to serialize +// subscription info in the embedded KV store. +type influxdbV1SubscriptionInfo struct { + Name string + Mode string + Destinations []string +} + +// extractBucketManifest reads a boltdb backed up from InfluxDB 2.0.x, converting a subset of the +// metadata it contains into a set of 2.1.x bucket manifests. +func extractBucketManifest(boltPath string) ([]api.BucketMetadataManifest, error) { + db, err := bbolt.Open(boltPath, 0666, &bbolt.Options{ReadOnly: true, Timeout: 1 * time.Second}) + if err != nil { + // Hack to give a slightly nicer error message for a known failure mode when bolt calls + // mmap on a file system that doesn't support the MAP_SHARED option. + // + // See: https://github.com/boltdb/bolt/issues/272 + // See: https://stackoverflow.com/a/18421071 + if err.Error() == "invalid argument" { + return nil, fmt.Errorf("unable to open boltdb: mmap of %q may not support the MAP_SHARED option", boltPath) + } + + return nil, fmt.Errorf("unable to open boltdb: %w", err) + } + defer db.Close() + + // Read raw metadata needed to construct a manifest. + var buckets []influxdbBucketSchema + orgNamesById := map[string]string{} + dbInfoByBucketId := map[string]influxdbV1DatabaseInfo{} + + if err := db.View(func(tx *bbolt.Tx) error { + bucketDB := tx.Bucket(bucketsBoltBucket) + if bucketDB == nil { + return errors.New("bucket metadata not found in local KV store") + } + + if err := bucketDB.ForEach(func(k, v []byte) error { + var b influxdbBucketSchema + if err := json.Unmarshal(v, &b); err != nil { + return err + } + if b.Type != 1 { // 1 == "system" + buckets = append(buckets, b) + } + return nil + }); err != nil { + return fmt.Errorf("failed to read bucket metadata from local KV store: %w", err) + } + + orgsDB := tx.Bucket(organizationsBoltBucket) + if orgsDB == nil { + return errors.New("organization metadata not found in local KV store") + } + + if err := orgsDB.ForEach(func(k, v []byte) error { + var o influxdbOrganizationSchema + if err := json.Unmarshal(v, &o); err != nil { + return err + } + orgNamesById[o.ID] = o.Name + return nil + }); err != nil { + return fmt.Errorf("failed to read organization metadata from local KV store: %w", err) + } + + v1DB := tx.Bucket(v1MetadataBoltBucket) + if v1DB == nil { + return errors.New("v1 database info not found in local KV store") + } + fullMeta := v1DB.Get(v1MetadataBoltKey) + if fullMeta == nil { + return errors.New("v1 database info not found in local KV store") + } + + var pb internal.Data + if err := proto.Unmarshal(fullMeta, &pb); err != nil { + return fmt.Errorf("failed to unmarshal v1 database info: %w", err) + } + for _, rawDBI := range pb.GetDatabases() { + if rawDBI == nil { + continue + } + unmarshalled := unmarshalRawDBI(*rawDBI) + dbInfoByBucketId[unmarshalled.Name] = unmarshalled + } + + return nil + }); err != nil { + return nil, err + } + + manifests := make([]api.BucketMetadataManifest, len(buckets)) + for i, b := range buckets { + orgName, ok := orgNamesById[b.OrgID] + if !ok { + return nil, fmt.Errorf("local KV store in inconsistent state: no organization found with ID %q", b.OrgID) + } + dbi, ok := dbInfoByBucketId[b.ID] + if !ok { + return nil, fmt.Errorf("local KV store in inconsistent state: no V1 database info found for bucket %q", b.Name) + } + manifests[i] = combineMetadata(b, orgName, dbi) + } + + return manifests, nil +} + +func unmarshalRawDBI(rawDBI internal.DatabaseInfo) influxdbV1DatabaseInfo { + dbi := influxdbV1DatabaseInfo{ + Name: rawDBI.GetName(), + DefaultRetentionPolicy: rawDBI.GetDefaultRetentionPolicy(), + RetentionPolicies: make([]influxdbV1RetentionPolicyInfo, 0, len(rawDBI.GetRetentionPolicies())), + } + for _, rp := range rawDBI.GetRetentionPolicies() { + if rp == nil { + continue + } + dbi.RetentionPolicies = append(dbi.RetentionPolicies, unmarshalRawRPI(*rp)) + } + return dbi +} + +func unmarshalRawRPI(rawRPI internal.RetentionPolicyInfo) influxdbV1RetentionPolicyInfo { + rpi := influxdbV1RetentionPolicyInfo{ + Name: rawRPI.GetName(), + ReplicaN: int32(rawRPI.GetReplicaN()), + Duration: rawRPI.GetDuration(), + ShardGroupDuration: rawRPI.GetShardGroupDuration(), + ShardGroups: make([]influxdbV1ShardGroupInfo, 0, len(rawRPI.GetShardGroups())), + Subscriptions: make([]influxdbV1SubscriptionInfo, 0, len(rawRPI.GetSubscriptions())), + } + for _, sg := range rawRPI.GetShardGroups() { + if sg == nil { + continue + } + rpi.ShardGroups = append(rpi.ShardGroups, unmarshalRawSGI(*sg)) + } + for _, s := range rawRPI.GetSubscriptions() { + if s == nil { + continue + } + rpi.Subscriptions = append(rpi.Subscriptions, influxdbV1SubscriptionInfo{ + Name: s.GetName(), + Mode: s.GetMode(), + Destinations: s.GetDestinations(), + }) + } + return rpi +} + +func unmarshalRawSGI(rawSGI internal.ShardGroupInfo) influxdbV1ShardGroupInfo { + sgi := influxdbV1ShardGroupInfo{ + ID: int64(rawSGI.GetID()), + StartTime: time.Unix(0, rawSGI.GetStartTime()).UTC(), + EndTime: time.Unix(0, rawSGI.GetEndTime()).UTC(), + DeletedAt: time.Unix(0, rawSGI.GetDeletedAt()).UTC(), + Shards: make([]influxdbV1ShardInfo, 0, len(rawSGI.GetShards())), + TruncatedAt: time.Unix(0, rawSGI.GetTruncatedAt()).UTC(), + } + for _, s := range rawSGI.GetShards() { + if s == nil { + continue + } + sgi.Shards = append(sgi.Shards, unmarshalRawShard(*s)) + } + return sgi +} + +func unmarshalRawShard(rawShard internal.ShardInfo) influxdbV1ShardInfo { + si := influxdbV1ShardInfo{ + ID: int64(rawShard.GetID()), + } + // If deprecated "OwnerIDs" exists then convert it to "Owners" format. + //lint:ignore SA1019 we need to check for the presence of the deprecated field so we can convert it + oldStyleOwnerIds := rawShard.GetOwnerIDs() + if len(oldStyleOwnerIds) > 0 { + si.Owners = make([]influxdbV1ShardOwnerInfo, len(oldStyleOwnerIds)) + for i, oid := range oldStyleOwnerIds { + si.Owners[i] = influxdbV1ShardOwnerInfo{NodeID: int64(oid)} + } + } else { + si.Owners = make([]influxdbV1ShardOwnerInfo, 0, len(rawShard.GetOwners())) + for _, o := range rawShard.GetOwners() { + if o == nil { + continue + } + si.Owners = append(si.Owners, influxdbV1ShardOwnerInfo{NodeID: int64(o.GetNodeID())}) + } + } + return si +} + +func combineMetadata(bucket influxdbBucketSchema, orgName string, dbi influxdbV1DatabaseInfo) api.BucketMetadataManifest { + m := api.BucketMetadataManifest{ + OrganizationID: bucket.OrgID, + OrganizationName: orgName, + BucketID: bucket.ID, + BucketName: bucket.Name, + DefaultRetentionPolicy: dbi.DefaultRetentionPolicy, + RetentionPolicies: make([]api.RetentionPolicyManifest, len(dbi.RetentionPolicies)), + } + if bucket.Description != nil && *bucket.Description != "" { + m.Description = bucket.Description + } + for i, rp := range dbi.RetentionPolicies { + m.RetentionPolicies[i] = convertRPI(rp) + } + return m +} + +func convertRPI(rpi influxdbV1RetentionPolicyInfo) api.RetentionPolicyManifest { + m := api.RetentionPolicyManifest{ + Name: rpi.Name, + ReplicaN: rpi.ReplicaN, + Duration: rpi.Duration, + ShardGroupDuration: rpi.ShardGroupDuration, + ShardGroups: make([]api.ShardGroupManifest, len(rpi.ShardGroups)), + Subscriptions: make([]api.SubscriptionManifest, len(rpi.Subscriptions)), + } + for i, sg := range rpi.ShardGroups { + m.ShardGroups[i] = convertSGI(sg) + } + for i, s := range rpi.Subscriptions { + m.Subscriptions[i] = api.SubscriptionManifest{ + Name: s.Name, + Mode: s.Mode, + Destinations: s.Destinations, + } + } + return m +} + +func convertSGI(sgi influxdbV1ShardGroupInfo) api.ShardGroupManifest { + m := api.ShardGroupManifest{ + Id: sgi.ID, + StartTime: sgi.StartTime, + EndTime: sgi.EndTime, + Shards: make([]api.ShardManifest, len(sgi.Shards)), + } + if sgi.DeletedAt.Unix() != 0 { + m.DeletedAt = &sgi.DeletedAt + } + if sgi.TruncatedAt.Unix() != 0 { + m.TruncatedAt = &sgi.TruncatedAt + } + for i, s := range sgi.Shards { + m.Shards[i] = convertShard(s) + } + return m +} + +func convertShard(shard influxdbV1ShardInfo) api.ShardManifest { + m := api.ShardManifest{ + Id: shard.ID, + ShardOwners: make([]api.ShardOwner, len(shard.Owners)), + } + for i, o := range shard.Owners { + m.ShardOwners[i] = api.ShardOwner{NodeID: o.NodeID} + } + return m +} diff --git a/clients/backup/bolt_internal_test.go b/clients/backup/bolt_internal_test.go new file mode 100644 index 00000000..f7dc3048 --- /dev/null +++ b/clients/backup/bolt_internal_test.go @@ -0,0 +1,106 @@ +package backup + +import ( + "compress/gzip" + "io" + "os" + "path/filepath" + "runtime" + "testing" + + "github.com/influxdata/influx-cli/v2/api" + "github.com/stretchr/testify/require" +) + +const testFile = "testdata/test.bolt.gz" + +func TestExtractManifest(t *testing.T) { + t.Parallel() + + if runtime.GOOS == "windows" { + t.Skip("skipping test on Windows: https://github.com/etcd-io/bbolt/issues/252") + } + + // Extract our example input into a format the bbolt client can use. + boltIn, err := os.Open(testFile) + require.NoError(t, err) + defer boltIn.Close() + gzipIn, err := gzip.NewReader(boltIn) + require.NoError(t, err) + defer gzipIn.Close() + + tmp, err := os.MkdirTemp("", "") + require.NoError(t, err) + defer os.RemoveAll(tmp) + + tmpBoltPath := filepath.Join(tmp, "test.bolt") + tmpBolt, err := os.Create(tmpBoltPath) + require.NoError(t, err) + + _, err = io.Copy(tmpBolt, gzipIn) + require.NoError(t, tmpBolt.Close()) + require.NoError(t, err) + + extracted, err := extractBucketManifest(tmpBoltPath) + require.NoError(t, err) + + expected := []api.BucketMetadataManifest{ + { + OrganizationID: "80c29010030b3d83", + OrganizationName: "test2", + BucketID: "5379ef2d1655b0ab", + BucketName: "test3", + DefaultRetentionPolicy: "autogen", + RetentionPolicies: []api.RetentionPolicyManifest{ + { + Name: "autogen", + ReplicaN: 1, + Duration: 0, + ShardGroupDuration: 604800000000000, + ShardGroups: []api.ShardGroupManifest{}, + Subscriptions: []api.SubscriptionManifest{}, + }, + }, + }, + { + OrganizationID: "375477729f9d7262", + OrganizationName: "test", + BucketID: "cce01ef3783e3678", + BucketName: "test2", + DefaultRetentionPolicy: "autogen", + RetentionPolicies: []api.RetentionPolicyManifest{ + { + Name: "autogen", + ReplicaN: 1, + Duration: 0, + ShardGroupDuration: 3600000000000, + ShardGroups: []api.ShardGroupManifest{}, + Subscriptions: []api.SubscriptionManifest{}, + }, + }, + }, + { + OrganizationID: "375477729f9d7262", + OrganizationName: "test", + BucketID: "d66c5360b5aa91b4", + BucketName: "test", + DefaultRetentionPolicy: "autogen", + RetentionPolicies: []api.RetentionPolicyManifest{ + { + Name: "autogen", + ReplicaN: 1, + Duration: 259200000000000, + ShardGroupDuration: 86400000000000, + ShardGroups: []api.ShardGroupManifest{}, + Subscriptions: []api.SubscriptionManifest{}, + }, + }, + }, + } + + require.Equal(t, len(expected), len(extracted)) + require.Equal(t, expected, extracted) + for _, e := range expected { + require.Contains(t, extracted, e) + } +} diff --git a/clients/backup/internal/README.md b/clients/backup/internal/README.md new file mode 100644 index 00000000..f3c4b342 --- /dev/null +++ b/clients/backup/internal/README.md @@ -0,0 +1,12 @@ +# V1 Meta Protobufs + +For compatibility with backups made via the v2.0.x `influx` CLI, we include logic +for opening & reading backed-up KV stores to derive bucket manifests. Part of that +process requires reading & unmarshalling V1 database info, serialized as protobuf. +To support that requirement, we've copied the `meta.proto` definition out of `influxdb` +and into this repository. This file isn't intended to be modified. + +If `meta.pb.go` ever needs to be re-generated, follow these steps: +1. Install `protoc` (i.e. via `brew install protobuf`) +2. Run `go install github.com/gogo/protobuf/protoc-gen-gogo` from within this repository +3. Run `go generate ` diff --git a/clients/backup/internal/meta.pb.go b/clients/backup/internal/meta.pb.go new file mode 100644 index 00000000..ec53cf56 --- /dev/null +++ b/clients/backup/internal/meta.pb.go @@ -0,0 +1,2867 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: internal/meta.proto + +package internal + +import ( + fmt "fmt" + math "math" + + proto "github.com/gogo/protobuf/proto" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type Command_Type int32 + +const ( + Command_CreateNodeCommand Command_Type = 1 + Command_DeleteNodeCommand Command_Type = 2 + Command_CreateDatabaseCommand Command_Type = 3 + Command_DropDatabaseCommand Command_Type = 4 + Command_CreateRetentionPolicyCommand Command_Type = 5 + Command_DropRetentionPolicyCommand Command_Type = 6 + Command_SetDefaultRetentionPolicyCommand Command_Type = 7 + Command_UpdateRetentionPolicyCommand Command_Type = 8 + Command_CreateShardGroupCommand Command_Type = 9 + Command_DeleteShardGroupCommand Command_Type = 10 + Command_CreateContinuousQueryCommand Command_Type = 11 + Command_DropContinuousQueryCommand Command_Type = 12 + Command_CreateUserCommand Command_Type = 13 + Command_DropUserCommand Command_Type = 14 + Command_UpdateUserCommand Command_Type = 15 + Command_SetPrivilegeCommand Command_Type = 16 + Command_SetDataCommand Command_Type = 17 + Command_SetAdminPrivilegeCommand Command_Type = 18 + Command_UpdateNodeCommand Command_Type = 19 + Command_CreateSubscriptionCommand Command_Type = 21 + Command_DropSubscriptionCommand Command_Type = 22 + Command_RemovePeerCommand Command_Type = 23 + Command_CreateMetaNodeCommand Command_Type = 24 + Command_CreateDataNodeCommand Command_Type = 25 + Command_UpdateDataNodeCommand Command_Type = 26 + Command_DeleteMetaNodeCommand Command_Type = 27 + Command_DeleteDataNodeCommand Command_Type = 28 + Command_SetMetaNodeCommand Command_Type = 29 + Command_DropShardCommand Command_Type = 30 +) + +var Command_Type_name = map[int32]string{ + 1: "CreateNodeCommand", + 2: "DeleteNodeCommand", + 3: "CreateDatabaseCommand", + 4: "DropDatabaseCommand", + 5: "CreateRetentionPolicyCommand", + 6: "DropRetentionPolicyCommand", + 7: "SetDefaultRetentionPolicyCommand", + 8: "UpdateRetentionPolicyCommand", + 9: "CreateShardGroupCommand", + 10: "DeleteShardGroupCommand", + 11: "CreateContinuousQueryCommand", + 12: "DropContinuousQueryCommand", + 13: "CreateUserCommand", + 14: "DropUserCommand", + 15: "UpdateUserCommand", + 16: "SetPrivilegeCommand", + 17: "SetDataCommand", + 18: "SetAdminPrivilegeCommand", + 19: "UpdateNodeCommand", + 21: "CreateSubscriptionCommand", + 22: "DropSubscriptionCommand", + 23: "RemovePeerCommand", + 24: "CreateMetaNodeCommand", + 25: "CreateDataNodeCommand", + 26: "UpdateDataNodeCommand", + 27: "DeleteMetaNodeCommand", + 28: "DeleteDataNodeCommand", + 29: "SetMetaNodeCommand", + 30: "DropShardCommand", +} + +var Command_Type_value = map[string]int32{ + "CreateNodeCommand": 1, + "DeleteNodeCommand": 2, + "CreateDatabaseCommand": 3, + "DropDatabaseCommand": 4, + "CreateRetentionPolicyCommand": 5, + "DropRetentionPolicyCommand": 6, + "SetDefaultRetentionPolicyCommand": 7, + "UpdateRetentionPolicyCommand": 8, + "CreateShardGroupCommand": 9, + "DeleteShardGroupCommand": 10, + "CreateContinuousQueryCommand": 11, + "DropContinuousQueryCommand": 12, + "CreateUserCommand": 13, + "DropUserCommand": 14, + "UpdateUserCommand": 15, + "SetPrivilegeCommand": 16, + "SetDataCommand": 17, + "SetAdminPrivilegeCommand": 18, + "UpdateNodeCommand": 19, + "CreateSubscriptionCommand": 21, + "DropSubscriptionCommand": 22, + "RemovePeerCommand": 23, + "CreateMetaNodeCommand": 24, + "CreateDataNodeCommand": 25, + "UpdateDataNodeCommand": 26, + "DeleteMetaNodeCommand": 27, + "DeleteDataNodeCommand": 28, + "SetMetaNodeCommand": 29, + "DropShardCommand": 30, +} + +func (x Command_Type) Enum() *Command_Type { + p := new(Command_Type) + *p = x + return p +} + +func (x Command_Type) String() string { + return proto.EnumName(Command_Type_name, int32(x)) +} + +func (x *Command_Type) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Command_Type_value, data, "Command_Type") + if err != nil { + return err + } + *x = Command_Type(value) + return nil +} + +func (Command_Type) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{12, 0} +} + +type Data struct { + Term *uint64 `protobuf:"varint,1,req,name=Term" json:"Term,omitempty"` + Index *uint64 `protobuf:"varint,2,req,name=Index" json:"Index,omitempty"` + ClusterID *uint64 `protobuf:"varint,3,req,name=ClusterID" json:"ClusterID,omitempty"` + Nodes []*NodeInfo `protobuf:"bytes,4,rep,name=Nodes" json:"Nodes,omitempty"` + Databases []*DatabaseInfo `protobuf:"bytes,5,rep,name=Databases" json:"Databases,omitempty"` + Users []*UserInfo `protobuf:"bytes,6,rep,name=Users" json:"Users,omitempty"` + MaxNodeID *uint64 `protobuf:"varint,7,req,name=MaxNodeID" json:"MaxNodeID,omitempty"` + MaxShardGroupID *uint64 `protobuf:"varint,8,req,name=MaxShardGroupID" json:"MaxShardGroupID,omitempty"` + MaxShardID *uint64 `protobuf:"varint,9,req,name=MaxShardID" json:"MaxShardID,omitempty"` + // added for 0.10.0 + DataNodes []*NodeInfo `protobuf:"bytes,10,rep,name=DataNodes" json:"DataNodes,omitempty"` + MetaNodes []*NodeInfo `protobuf:"bytes,11,rep,name=MetaNodes" json:"MetaNodes,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Data) Reset() { *m = Data{} } +func (m *Data) String() string { return proto.CompactTextString(m) } +func (*Data) ProtoMessage() {} +func (*Data) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{0} +} +func (m *Data) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Data.Unmarshal(m, b) +} +func (m *Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Data.Marshal(b, m, deterministic) +} +func (m *Data) XXX_Merge(src proto.Message) { + xxx_messageInfo_Data.Merge(m, src) +} +func (m *Data) XXX_Size() int { + return xxx_messageInfo_Data.Size(m) +} +func (m *Data) XXX_DiscardUnknown() { + xxx_messageInfo_Data.DiscardUnknown(m) +} + +var xxx_messageInfo_Data proto.InternalMessageInfo + +func (m *Data) GetTerm() uint64 { + if m != nil && m.Term != nil { + return *m.Term + } + return 0 +} + +func (m *Data) GetIndex() uint64 { + if m != nil && m.Index != nil { + return *m.Index + } + return 0 +} + +func (m *Data) GetClusterID() uint64 { + if m != nil && m.ClusterID != nil { + return *m.ClusterID + } + return 0 +} + +func (m *Data) GetNodes() []*NodeInfo { + if m != nil { + return m.Nodes + } + return nil +} + +func (m *Data) GetDatabases() []*DatabaseInfo { + if m != nil { + return m.Databases + } + return nil +} + +func (m *Data) GetUsers() []*UserInfo { + if m != nil { + return m.Users + } + return nil +} + +func (m *Data) GetMaxNodeID() uint64 { + if m != nil && m.MaxNodeID != nil { + return *m.MaxNodeID + } + return 0 +} + +func (m *Data) GetMaxShardGroupID() uint64 { + if m != nil && m.MaxShardGroupID != nil { + return *m.MaxShardGroupID + } + return 0 +} + +func (m *Data) GetMaxShardID() uint64 { + if m != nil && m.MaxShardID != nil { + return *m.MaxShardID + } + return 0 +} + +func (m *Data) GetDataNodes() []*NodeInfo { + if m != nil { + return m.DataNodes + } + return nil +} + +func (m *Data) GetMetaNodes() []*NodeInfo { + if m != nil { + return m.MetaNodes + } + return nil +} + +type NodeInfo struct { + ID *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"` + Host *string `protobuf:"bytes,2,req,name=Host" json:"Host,omitempty"` + TCPHost *string `protobuf:"bytes,3,opt,name=TCPHost" json:"TCPHost,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *NodeInfo) Reset() { *m = NodeInfo{} } +func (m *NodeInfo) String() string { return proto.CompactTextString(m) } +func (*NodeInfo) ProtoMessage() {} +func (*NodeInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{1} +} +func (m *NodeInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_NodeInfo.Unmarshal(m, b) +} +func (m *NodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_NodeInfo.Marshal(b, m, deterministic) +} +func (m *NodeInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_NodeInfo.Merge(m, src) +} +func (m *NodeInfo) XXX_Size() int { + return xxx_messageInfo_NodeInfo.Size(m) +} +func (m *NodeInfo) XXX_DiscardUnknown() { + xxx_messageInfo_NodeInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_NodeInfo proto.InternalMessageInfo + +func (m *NodeInfo) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +func (m *NodeInfo) GetHost() string { + if m != nil && m.Host != nil { + return *m.Host + } + return "" +} + +func (m *NodeInfo) GetTCPHost() string { + if m != nil && m.TCPHost != nil { + return *m.TCPHost + } + return "" +} + +type DatabaseInfo struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + DefaultRetentionPolicy *string `protobuf:"bytes,2,req,name=DefaultRetentionPolicy" json:"DefaultRetentionPolicy,omitempty"` + RetentionPolicies []*RetentionPolicyInfo `protobuf:"bytes,3,rep,name=RetentionPolicies" json:"RetentionPolicies,omitempty"` + ContinuousQueries []*ContinuousQueryInfo `protobuf:"bytes,4,rep,name=ContinuousQueries" json:"ContinuousQueries,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DatabaseInfo) Reset() { *m = DatabaseInfo{} } +func (m *DatabaseInfo) String() string { return proto.CompactTextString(m) } +func (*DatabaseInfo) ProtoMessage() {} +func (*DatabaseInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{2} +} +func (m *DatabaseInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DatabaseInfo.Unmarshal(m, b) +} +func (m *DatabaseInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DatabaseInfo.Marshal(b, m, deterministic) +} +func (m *DatabaseInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_DatabaseInfo.Merge(m, src) +} +func (m *DatabaseInfo) XXX_Size() int { + return xxx_messageInfo_DatabaseInfo.Size(m) +} +func (m *DatabaseInfo) XXX_DiscardUnknown() { + xxx_messageInfo_DatabaseInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_DatabaseInfo proto.InternalMessageInfo + +func (m *DatabaseInfo) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *DatabaseInfo) GetDefaultRetentionPolicy() string { + if m != nil && m.DefaultRetentionPolicy != nil { + return *m.DefaultRetentionPolicy + } + return "" +} + +func (m *DatabaseInfo) GetRetentionPolicies() []*RetentionPolicyInfo { + if m != nil { + return m.RetentionPolicies + } + return nil +} + +func (m *DatabaseInfo) GetContinuousQueries() []*ContinuousQueryInfo { + if m != nil { + return m.ContinuousQueries + } + return nil +} + +type RetentionPolicySpec struct { + Name *string `protobuf:"bytes,1,opt,name=Name" json:"Name,omitempty"` + Duration *int64 `protobuf:"varint,2,opt,name=Duration" json:"Duration,omitempty"` + ShardGroupDuration *int64 `protobuf:"varint,3,opt,name=ShardGroupDuration" json:"ShardGroupDuration,omitempty"` + ReplicaN *uint32 `protobuf:"varint,4,opt,name=ReplicaN" json:"ReplicaN,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RetentionPolicySpec) Reset() { *m = RetentionPolicySpec{} } +func (m *RetentionPolicySpec) String() string { return proto.CompactTextString(m) } +func (*RetentionPolicySpec) ProtoMessage() {} +func (*RetentionPolicySpec) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{3} +} +func (m *RetentionPolicySpec) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RetentionPolicySpec.Unmarshal(m, b) +} +func (m *RetentionPolicySpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RetentionPolicySpec.Marshal(b, m, deterministic) +} +func (m *RetentionPolicySpec) XXX_Merge(src proto.Message) { + xxx_messageInfo_RetentionPolicySpec.Merge(m, src) +} +func (m *RetentionPolicySpec) XXX_Size() int { + return xxx_messageInfo_RetentionPolicySpec.Size(m) +} +func (m *RetentionPolicySpec) XXX_DiscardUnknown() { + xxx_messageInfo_RetentionPolicySpec.DiscardUnknown(m) +} + +var xxx_messageInfo_RetentionPolicySpec proto.InternalMessageInfo + +func (m *RetentionPolicySpec) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *RetentionPolicySpec) GetDuration() int64 { + if m != nil && m.Duration != nil { + return *m.Duration + } + return 0 +} + +func (m *RetentionPolicySpec) GetShardGroupDuration() int64 { + if m != nil && m.ShardGroupDuration != nil { + return *m.ShardGroupDuration + } + return 0 +} + +func (m *RetentionPolicySpec) GetReplicaN() uint32 { + if m != nil && m.ReplicaN != nil { + return *m.ReplicaN + } + return 0 +} + +type RetentionPolicyInfo struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + Duration *int64 `protobuf:"varint,2,req,name=Duration" json:"Duration,omitempty"` + ShardGroupDuration *int64 `protobuf:"varint,3,req,name=ShardGroupDuration" json:"ShardGroupDuration,omitempty"` + ReplicaN *uint32 `protobuf:"varint,4,req,name=ReplicaN" json:"ReplicaN,omitempty"` + ShardGroups []*ShardGroupInfo `protobuf:"bytes,5,rep,name=ShardGroups" json:"ShardGroups,omitempty"` + Subscriptions []*SubscriptionInfo `protobuf:"bytes,6,rep,name=Subscriptions" json:"Subscriptions,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RetentionPolicyInfo) Reset() { *m = RetentionPolicyInfo{} } +func (m *RetentionPolicyInfo) String() string { return proto.CompactTextString(m) } +func (*RetentionPolicyInfo) ProtoMessage() {} +func (*RetentionPolicyInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{4} +} +func (m *RetentionPolicyInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RetentionPolicyInfo.Unmarshal(m, b) +} +func (m *RetentionPolicyInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RetentionPolicyInfo.Marshal(b, m, deterministic) +} +func (m *RetentionPolicyInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_RetentionPolicyInfo.Merge(m, src) +} +func (m *RetentionPolicyInfo) XXX_Size() int { + return xxx_messageInfo_RetentionPolicyInfo.Size(m) +} +func (m *RetentionPolicyInfo) XXX_DiscardUnknown() { + xxx_messageInfo_RetentionPolicyInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_RetentionPolicyInfo proto.InternalMessageInfo + +func (m *RetentionPolicyInfo) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *RetentionPolicyInfo) GetDuration() int64 { + if m != nil && m.Duration != nil { + return *m.Duration + } + return 0 +} + +func (m *RetentionPolicyInfo) GetShardGroupDuration() int64 { + if m != nil && m.ShardGroupDuration != nil { + return *m.ShardGroupDuration + } + return 0 +} + +func (m *RetentionPolicyInfo) GetReplicaN() uint32 { + if m != nil && m.ReplicaN != nil { + return *m.ReplicaN + } + return 0 +} + +func (m *RetentionPolicyInfo) GetShardGroups() []*ShardGroupInfo { + if m != nil { + return m.ShardGroups + } + return nil +} + +func (m *RetentionPolicyInfo) GetSubscriptions() []*SubscriptionInfo { + if m != nil { + return m.Subscriptions + } + return nil +} + +type ShardGroupInfo struct { + ID *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"` + StartTime *int64 `protobuf:"varint,2,req,name=StartTime" json:"StartTime,omitempty"` + EndTime *int64 `protobuf:"varint,3,req,name=EndTime" json:"EndTime,omitempty"` + DeletedAt *int64 `protobuf:"varint,4,req,name=DeletedAt" json:"DeletedAt,omitempty"` + Shards []*ShardInfo `protobuf:"bytes,5,rep,name=Shards" json:"Shards,omitempty"` + TruncatedAt *int64 `protobuf:"varint,6,opt,name=TruncatedAt" json:"TruncatedAt,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ShardGroupInfo) Reset() { *m = ShardGroupInfo{} } +func (m *ShardGroupInfo) String() string { return proto.CompactTextString(m) } +func (*ShardGroupInfo) ProtoMessage() {} +func (*ShardGroupInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{5} +} +func (m *ShardGroupInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ShardGroupInfo.Unmarshal(m, b) +} +func (m *ShardGroupInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ShardGroupInfo.Marshal(b, m, deterministic) +} +func (m *ShardGroupInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ShardGroupInfo.Merge(m, src) +} +func (m *ShardGroupInfo) XXX_Size() int { + return xxx_messageInfo_ShardGroupInfo.Size(m) +} +func (m *ShardGroupInfo) XXX_DiscardUnknown() { + xxx_messageInfo_ShardGroupInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_ShardGroupInfo proto.InternalMessageInfo + +func (m *ShardGroupInfo) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +func (m *ShardGroupInfo) GetStartTime() int64 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *ShardGroupInfo) GetEndTime() int64 { + if m != nil && m.EndTime != nil { + return *m.EndTime + } + return 0 +} + +func (m *ShardGroupInfo) GetDeletedAt() int64 { + if m != nil && m.DeletedAt != nil { + return *m.DeletedAt + } + return 0 +} + +func (m *ShardGroupInfo) GetShards() []*ShardInfo { + if m != nil { + return m.Shards + } + return nil +} + +func (m *ShardGroupInfo) GetTruncatedAt() int64 { + if m != nil && m.TruncatedAt != nil { + return *m.TruncatedAt + } + return 0 +} + +type ShardInfo struct { + ID *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"` + OwnerIDs []uint64 `protobuf:"varint,2,rep,name=OwnerIDs" json:"OwnerIDs,omitempty"` // Deprecated: Do not use. + Owners []*ShardOwner `protobuf:"bytes,3,rep,name=Owners" json:"Owners,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ShardInfo) Reset() { *m = ShardInfo{} } +func (m *ShardInfo) String() string { return proto.CompactTextString(m) } +func (*ShardInfo) ProtoMessage() {} +func (*ShardInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{6} +} +func (m *ShardInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ShardInfo.Unmarshal(m, b) +} +func (m *ShardInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ShardInfo.Marshal(b, m, deterministic) +} +func (m *ShardInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ShardInfo.Merge(m, src) +} +func (m *ShardInfo) XXX_Size() int { + return xxx_messageInfo_ShardInfo.Size(m) +} +func (m *ShardInfo) XXX_DiscardUnknown() { + xxx_messageInfo_ShardInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_ShardInfo proto.InternalMessageInfo + +func (m *ShardInfo) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +// Deprecated: Do not use. +func (m *ShardInfo) GetOwnerIDs() []uint64 { + if m != nil { + return m.OwnerIDs + } + return nil +} + +func (m *ShardInfo) GetOwners() []*ShardOwner { + if m != nil { + return m.Owners + } + return nil +} + +type SubscriptionInfo struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + Mode *string `protobuf:"bytes,2,req,name=Mode" json:"Mode,omitempty"` + Destinations []string `protobuf:"bytes,3,rep,name=Destinations" json:"Destinations,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SubscriptionInfo) Reset() { *m = SubscriptionInfo{} } +func (m *SubscriptionInfo) String() string { return proto.CompactTextString(m) } +func (*SubscriptionInfo) ProtoMessage() {} +func (*SubscriptionInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{7} +} +func (m *SubscriptionInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SubscriptionInfo.Unmarshal(m, b) +} +func (m *SubscriptionInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SubscriptionInfo.Marshal(b, m, deterministic) +} +func (m *SubscriptionInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_SubscriptionInfo.Merge(m, src) +} +func (m *SubscriptionInfo) XXX_Size() int { + return xxx_messageInfo_SubscriptionInfo.Size(m) +} +func (m *SubscriptionInfo) XXX_DiscardUnknown() { + xxx_messageInfo_SubscriptionInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_SubscriptionInfo proto.InternalMessageInfo + +func (m *SubscriptionInfo) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *SubscriptionInfo) GetMode() string { + if m != nil && m.Mode != nil { + return *m.Mode + } + return "" +} + +func (m *SubscriptionInfo) GetDestinations() []string { + if m != nil { + return m.Destinations + } + return nil +} + +type ShardOwner struct { + NodeID *uint64 `protobuf:"varint,1,req,name=NodeID" json:"NodeID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ShardOwner) Reset() { *m = ShardOwner{} } +func (m *ShardOwner) String() string { return proto.CompactTextString(m) } +func (*ShardOwner) ProtoMessage() {} +func (*ShardOwner) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{8} +} +func (m *ShardOwner) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ShardOwner.Unmarshal(m, b) +} +func (m *ShardOwner) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ShardOwner.Marshal(b, m, deterministic) +} +func (m *ShardOwner) XXX_Merge(src proto.Message) { + xxx_messageInfo_ShardOwner.Merge(m, src) +} +func (m *ShardOwner) XXX_Size() int { + return xxx_messageInfo_ShardOwner.Size(m) +} +func (m *ShardOwner) XXX_DiscardUnknown() { + xxx_messageInfo_ShardOwner.DiscardUnknown(m) +} + +var xxx_messageInfo_ShardOwner proto.InternalMessageInfo + +func (m *ShardOwner) GetNodeID() uint64 { + if m != nil && m.NodeID != nil { + return *m.NodeID + } + return 0 +} + +type ContinuousQueryInfo struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + Query *string `protobuf:"bytes,2,req,name=Query" json:"Query,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ContinuousQueryInfo) Reset() { *m = ContinuousQueryInfo{} } +func (m *ContinuousQueryInfo) String() string { return proto.CompactTextString(m) } +func (*ContinuousQueryInfo) ProtoMessage() {} +func (*ContinuousQueryInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{9} +} +func (m *ContinuousQueryInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_ContinuousQueryInfo.Unmarshal(m, b) +} +func (m *ContinuousQueryInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_ContinuousQueryInfo.Marshal(b, m, deterministic) +} +func (m *ContinuousQueryInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_ContinuousQueryInfo.Merge(m, src) +} +func (m *ContinuousQueryInfo) XXX_Size() int { + return xxx_messageInfo_ContinuousQueryInfo.Size(m) +} +func (m *ContinuousQueryInfo) XXX_DiscardUnknown() { + xxx_messageInfo_ContinuousQueryInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_ContinuousQueryInfo proto.InternalMessageInfo + +func (m *ContinuousQueryInfo) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *ContinuousQueryInfo) GetQuery() string { + if m != nil && m.Query != nil { + return *m.Query + } + return "" +} + +type UserInfo struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + Hash *string `protobuf:"bytes,2,req,name=Hash" json:"Hash,omitempty"` + Admin *bool `protobuf:"varint,3,req,name=Admin" json:"Admin,omitempty"` + Privileges []*UserPrivilege `protobuf:"bytes,4,rep,name=Privileges" json:"Privileges,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UserInfo) Reset() { *m = UserInfo{} } +func (m *UserInfo) String() string { return proto.CompactTextString(m) } +func (*UserInfo) ProtoMessage() {} +func (*UserInfo) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{10} +} +func (m *UserInfo) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UserInfo.Unmarshal(m, b) +} +func (m *UserInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UserInfo.Marshal(b, m, deterministic) +} +func (m *UserInfo) XXX_Merge(src proto.Message) { + xxx_messageInfo_UserInfo.Merge(m, src) +} +func (m *UserInfo) XXX_Size() int { + return xxx_messageInfo_UserInfo.Size(m) +} +func (m *UserInfo) XXX_DiscardUnknown() { + xxx_messageInfo_UserInfo.DiscardUnknown(m) +} + +var xxx_messageInfo_UserInfo proto.InternalMessageInfo + +func (m *UserInfo) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *UserInfo) GetHash() string { + if m != nil && m.Hash != nil { + return *m.Hash + } + return "" +} + +func (m *UserInfo) GetAdmin() bool { + if m != nil && m.Admin != nil { + return *m.Admin + } + return false +} + +func (m *UserInfo) GetPrivileges() []*UserPrivilege { + if m != nil { + return m.Privileges + } + return nil +} + +type UserPrivilege struct { + Database *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"` + Privilege *int32 `protobuf:"varint,2,req,name=Privilege" json:"Privilege,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UserPrivilege) Reset() { *m = UserPrivilege{} } +func (m *UserPrivilege) String() string { return proto.CompactTextString(m) } +func (*UserPrivilege) ProtoMessage() {} +func (*UserPrivilege) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{11} +} +func (m *UserPrivilege) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UserPrivilege.Unmarshal(m, b) +} +func (m *UserPrivilege) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UserPrivilege.Marshal(b, m, deterministic) +} +func (m *UserPrivilege) XXX_Merge(src proto.Message) { + xxx_messageInfo_UserPrivilege.Merge(m, src) +} +func (m *UserPrivilege) XXX_Size() int { + return xxx_messageInfo_UserPrivilege.Size(m) +} +func (m *UserPrivilege) XXX_DiscardUnknown() { + xxx_messageInfo_UserPrivilege.DiscardUnknown(m) +} + +var xxx_messageInfo_UserPrivilege proto.InternalMessageInfo + +func (m *UserPrivilege) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *UserPrivilege) GetPrivilege() int32 { + if m != nil && m.Privilege != nil { + return *m.Privilege + } + return 0 +} + +type Command struct { + Type *Command_Type `protobuf:"varint,1,req,name=type,enum=internal.Command_Type" json:"type,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + proto.XXX_InternalExtensions `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Command) Reset() { *m = Command{} } +func (m *Command) String() string { return proto.CompactTextString(m) } +func (*Command) ProtoMessage() {} +func (*Command) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{12} +} + +var extRange_Command = []proto.ExtensionRange{ + {Start: 100, End: 536870911}, +} + +func (*Command) ExtensionRangeArray() []proto.ExtensionRange { + return extRange_Command +} + +func (m *Command) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Command.Unmarshal(m, b) +} +func (m *Command) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Command.Marshal(b, m, deterministic) +} +func (m *Command) XXX_Merge(src proto.Message) { + xxx_messageInfo_Command.Merge(m, src) +} +func (m *Command) XXX_Size() int { + return xxx_messageInfo_Command.Size(m) +} +func (m *Command) XXX_DiscardUnknown() { + xxx_messageInfo_Command.DiscardUnknown(m) +} + +var xxx_messageInfo_Command proto.InternalMessageInfo + +func (m *Command) GetType() Command_Type { + if m != nil && m.Type != nil { + return *m.Type + } + return Command_CreateNodeCommand +} + +// This isn't used in >= 0.10.0. Kept around for upgrade purposes. Instead +// look at CreateDataNodeCommand and CreateMetaNodeCommand +type CreateNodeCommand struct { + Host *string `protobuf:"bytes,1,req,name=Host" json:"Host,omitempty"` + Rand *uint64 `protobuf:"varint,2,req,name=Rand" json:"Rand,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreateNodeCommand) Reset() { *m = CreateNodeCommand{} } +func (m *CreateNodeCommand) String() string { return proto.CompactTextString(m) } +func (*CreateNodeCommand) ProtoMessage() {} +func (*CreateNodeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{13} +} +func (m *CreateNodeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreateNodeCommand.Unmarshal(m, b) +} +func (m *CreateNodeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreateNodeCommand.Marshal(b, m, deterministic) +} +func (m *CreateNodeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreateNodeCommand.Merge(m, src) +} +func (m *CreateNodeCommand) XXX_Size() int { + return xxx_messageInfo_CreateNodeCommand.Size(m) +} +func (m *CreateNodeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_CreateNodeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_CreateNodeCommand proto.InternalMessageInfo + +func (m *CreateNodeCommand) GetHost() string { + if m != nil && m.Host != nil { + return *m.Host + } + return "" +} + +func (m *CreateNodeCommand) GetRand() uint64 { + if m != nil && m.Rand != nil { + return *m.Rand + } + return 0 +} + +var E_CreateNodeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*CreateNodeCommand)(nil), + Field: 101, + Name: "internal.CreateNodeCommand.command", + Tag: "bytes,101,opt,name=command", + Filename: "internal/meta.proto", +} + +type DeleteNodeCommand struct { + ID *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"` + Force *bool `protobuf:"varint,2,req,name=Force" json:"Force,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteNodeCommand) Reset() { *m = DeleteNodeCommand{} } +func (m *DeleteNodeCommand) String() string { return proto.CompactTextString(m) } +func (*DeleteNodeCommand) ProtoMessage() {} +func (*DeleteNodeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{14} +} +func (m *DeleteNodeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DeleteNodeCommand.Unmarshal(m, b) +} +func (m *DeleteNodeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DeleteNodeCommand.Marshal(b, m, deterministic) +} +func (m *DeleteNodeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteNodeCommand.Merge(m, src) +} +func (m *DeleteNodeCommand) XXX_Size() int { + return xxx_messageInfo_DeleteNodeCommand.Size(m) +} +func (m *DeleteNodeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteNodeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DeleteNodeCommand proto.InternalMessageInfo + +func (m *DeleteNodeCommand) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +func (m *DeleteNodeCommand) GetForce() bool { + if m != nil && m.Force != nil { + return *m.Force + } + return false +} + +var E_DeleteNodeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DeleteNodeCommand)(nil), + Field: 102, + Name: "internal.DeleteNodeCommand.command", + Tag: "bytes,102,opt,name=command", + Filename: "internal/meta.proto", +} + +type CreateDatabaseCommand struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + RetentionPolicy *RetentionPolicyInfo `protobuf:"bytes,2,opt,name=RetentionPolicy" json:"RetentionPolicy,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreateDatabaseCommand) Reset() { *m = CreateDatabaseCommand{} } +func (m *CreateDatabaseCommand) String() string { return proto.CompactTextString(m) } +func (*CreateDatabaseCommand) ProtoMessage() {} +func (*CreateDatabaseCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{15} +} +func (m *CreateDatabaseCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreateDatabaseCommand.Unmarshal(m, b) +} +func (m *CreateDatabaseCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreateDatabaseCommand.Marshal(b, m, deterministic) +} +func (m *CreateDatabaseCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreateDatabaseCommand.Merge(m, src) +} +func (m *CreateDatabaseCommand) XXX_Size() int { + return xxx_messageInfo_CreateDatabaseCommand.Size(m) +} +func (m *CreateDatabaseCommand) XXX_DiscardUnknown() { + xxx_messageInfo_CreateDatabaseCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_CreateDatabaseCommand proto.InternalMessageInfo + +func (m *CreateDatabaseCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CreateDatabaseCommand) GetRetentionPolicy() *RetentionPolicyInfo { + if m != nil { + return m.RetentionPolicy + } + return nil +} + +var E_CreateDatabaseCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*CreateDatabaseCommand)(nil), + Field: 103, + Name: "internal.CreateDatabaseCommand.command", + Tag: "bytes,103,opt,name=command", + Filename: "internal/meta.proto", +} + +type DropDatabaseCommand struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DropDatabaseCommand) Reset() { *m = DropDatabaseCommand{} } +func (m *DropDatabaseCommand) String() string { return proto.CompactTextString(m) } +func (*DropDatabaseCommand) ProtoMessage() {} +func (*DropDatabaseCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{16} +} +func (m *DropDatabaseCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DropDatabaseCommand.Unmarshal(m, b) +} +func (m *DropDatabaseCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DropDatabaseCommand.Marshal(b, m, deterministic) +} +func (m *DropDatabaseCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DropDatabaseCommand.Merge(m, src) +} +func (m *DropDatabaseCommand) XXX_Size() int { + return xxx_messageInfo_DropDatabaseCommand.Size(m) +} +func (m *DropDatabaseCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DropDatabaseCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DropDatabaseCommand proto.InternalMessageInfo + +func (m *DropDatabaseCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +var E_DropDatabaseCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DropDatabaseCommand)(nil), + Field: 104, + Name: "internal.DropDatabaseCommand.command", + Tag: "bytes,104,opt,name=command", + Filename: "internal/meta.proto", +} + +type CreateRetentionPolicyCommand struct { + Database *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"` + RetentionPolicy *RetentionPolicyInfo `protobuf:"bytes,2,req,name=RetentionPolicy" json:"RetentionPolicy,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreateRetentionPolicyCommand) Reset() { *m = CreateRetentionPolicyCommand{} } +func (m *CreateRetentionPolicyCommand) String() string { return proto.CompactTextString(m) } +func (*CreateRetentionPolicyCommand) ProtoMessage() {} +func (*CreateRetentionPolicyCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{17} +} +func (m *CreateRetentionPolicyCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreateRetentionPolicyCommand.Unmarshal(m, b) +} +func (m *CreateRetentionPolicyCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreateRetentionPolicyCommand.Marshal(b, m, deterministic) +} +func (m *CreateRetentionPolicyCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreateRetentionPolicyCommand.Merge(m, src) +} +func (m *CreateRetentionPolicyCommand) XXX_Size() int { + return xxx_messageInfo_CreateRetentionPolicyCommand.Size(m) +} +func (m *CreateRetentionPolicyCommand) XXX_DiscardUnknown() { + xxx_messageInfo_CreateRetentionPolicyCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_CreateRetentionPolicyCommand proto.InternalMessageInfo + +func (m *CreateRetentionPolicyCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *CreateRetentionPolicyCommand) GetRetentionPolicy() *RetentionPolicyInfo { + if m != nil { + return m.RetentionPolicy + } + return nil +} + +var E_CreateRetentionPolicyCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*CreateRetentionPolicyCommand)(nil), + Field: 105, + Name: "internal.CreateRetentionPolicyCommand.command", + Tag: "bytes,105,opt,name=command", + Filename: "internal/meta.proto", +} + +type DropRetentionPolicyCommand struct { + Database *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"` + Name *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DropRetentionPolicyCommand) Reset() { *m = DropRetentionPolicyCommand{} } +func (m *DropRetentionPolicyCommand) String() string { return proto.CompactTextString(m) } +func (*DropRetentionPolicyCommand) ProtoMessage() {} +func (*DropRetentionPolicyCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{18} +} +func (m *DropRetentionPolicyCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DropRetentionPolicyCommand.Unmarshal(m, b) +} +func (m *DropRetentionPolicyCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DropRetentionPolicyCommand.Marshal(b, m, deterministic) +} +func (m *DropRetentionPolicyCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DropRetentionPolicyCommand.Merge(m, src) +} +func (m *DropRetentionPolicyCommand) XXX_Size() int { + return xxx_messageInfo_DropRetentionPolicyCommand.Size(m) +} +func (m *DropRetentionPolicyCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DropRetentionPolicyCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DropRetentionPolicyCommand proto.InternalMessageInfo + +func (m *DropRetentionPolicyCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *DropRetentionPolicyCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +var E_DropRetentionPolicyCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DropRetentionPolicyCommand)(nil), + Field: 106, + Name: "internal.DropRetentionPolicyCommand.command", + Tag: "bytes,106,opt,name=command", + Filename: "internal/meta.proto", +} + +type SetDefaultRetentionPolicyCommand struct { + Database *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"` + Name *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SetDefaultRetentionPolicyCommand) Reset() { *m = SetDefaultRetentionPolicyCommand{} } +func (m *SetDefaultRetentionPolicyCommand) String() string { return proto.CompactTextString(m) } +func (*SetDefaultRetentionPolicyCommand) ProtoMessage() {} +func (*SetDefaultRetentionPolicyCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{19} +} +func (m *SetDefaultRetentionPolicyCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SetDefaultRetentionPolicyCommand.Unmarshal(m, b) +} +func (m *SetDefaultRetentionPolicyCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SetDefaultRetentionPolicyCommand.Marshal(b, m, deterministic) +} +func (m *SetDefaultRetentionPolicyCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetDefaultRetentionPolicyCommand.Merge(m, src) +} +func (m *SetDefaultRetentionPolicyCommand) XXX_Size() int { + return xxx_messageInfo_SetDefaultRetentionPolicyCommand.Size(m) +} +func (m *SetDefaultRetentionPolicyCommand) XXX_DiscardUnknown() { + xxx_messageInfo_SetDefaultRetentionPolicyCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_SetDefaultRetentionPolicyCommand proto.InternalMessageInfo + +func (m *SetDefaultRetentionPolicyCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *SetDefaultRetentionPolicyCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +var E_SetDefaultRetentionPolicyCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*SetDefaultRetentionPolicyCommand)(nil), + Field: 107, + Name: "internal.SetDefaultRetentionPolicyCommand.command", + Tag: "bytes,107,opt,name=command", + Filename: "internal/meta.proto", +} + +type UpdateRetentionPolicyCommand struct { + Database *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"` + Name *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"` + NewName *string `protobuf:"bytes,3,opt,name=NewName" json:"NewName,omitempty"` + Duration *int64 `protobuf:"varint,4,opt,name=Duration" json:"Duration,omitempty"` + ReplicaN *uint32 `protobuf:"varint,5,opt,name=ReplicaN" json:"ReplicaN,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateRetentionPolicyCommand) Reset() { *m = UpdateRetentionPolicyCommand{} } +func (m *UpdateRetentionPolicyCommand) String() string { return proto.CompactTextString(m) } +func (*UpdateRetentionPolicyCommand) ProtoMessage() {} +func (*UpdateRetentionPolicyCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{20} +} +func (m *UpdateRetentionPolicyCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UpdateRetentionPolicyCommand.Unmarshal(m, b) +} +func (m *UpdateRetentionPolicyCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UpdateRetentionPolicyCommand.Marshal(b, m, deterministic) +} +func (m *UpdateRetentionPolicyCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateRetentionPolicyCommand.Merge(m, src) +} +func (m *UpdateRetentionPolicyCommand) XXX_Size() int { + return xxx_messageInfo_UpdateRetentionPolicyCommand.Size(m) +} +func (m *UpdateRetentionPolicyCommand) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateRetentionPolicyCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateRetentionPolicyCommand proto.InternalMessageInfo + +func (m *UpdateRetentionPolicyCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *UpdateRetentionPolicyCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *UpdateRetentionPolicyCommand) GetNewName() string { + if m != nil && m.NewName != nil { + return *m.NewName + } + return "" +} + +func (m *UpdateRetentionPolicyCommand) GetDuration() int64 { + if m != nil && m.Duration != nil { + return *m.Duration + } + return 0 +} + +func (m *UpdateRetentionPolicyCommand) GetReplicaN() uint32 { + if m != nil && m.ReplicaN != nil { + return *m.ReplicaN + } + return 0 +} + +var E_UpdateRetentionPolicyCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*UpdateRetentionPolicyCommand)(nil), + Field: 108, + Name: "internal.UpdateRetentionPolicyCommand.command", + Tag: "bytes,108,opt,name=command", + Filename: "internal/meta.proto", +} + +type CreateShardGroupCommand struct { + Database *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"` + Policy *string `protobuf:"bytes,2,req,name=Policy" json:"Policy,omitempty"` + Timestamp *int64 `protobuf:"varint,3,req,name=Timestamp" json:"Timestamp,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreateShardGroupCommand) Reset() { *m = CreateShardGroupCommand{} } +func (m *CreateShardGroupCommand) String() string { return proto.CompactTextString(m) } +func (*CreateShardGroupCommand) ProtoMessage() {} +func (*CreateShardGroupCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{21} +} +func (m *CreateShardGroupCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreateShardGroupCommand.Unmarshal(m, b) +} +func (m *CreateShardGroupCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreateShardGroupCommand.Marshal(b, m, deterministic) +} +func (m *CreateShardGroupCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreateShardGroupCommand.Merge(m, src) +} +func (m *CreateShardGroupCommand) XXX_Size() int { + return xxx_messageInfo_CreateShardGroupCommand.Size(m) +} +func (m *CreateShardGroupCommand) XXX_DiscardUnknown() { + xxx_messageInfo_CreateShardGroupCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_CreateShardGroupCommand proto.InternalMessageInfo + +func (m *CreateShardGroupCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *CreateShardGroupCommand) GetPolicy() string { + if m != nil && m.Policy != nil { + return *m.Policy + } + return "" +} + +func (m *CreateShardGroupCommand) GetTimestamp() int64 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +var E_CreateShardGroupCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*CreateShardGroupCommand)(nil), + Field: 109, + Name: "internal.CreateShardGroupCommand.command", + Tag: "bytes,109,opt,name=command", + Filename: "internal/meta.proto", +} + +type DeleteShardGroupCommand struct { + Database *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"` + Policy *string `protobuf:"bytes,2,req,name=Policy" json:"Policy,omitempty"` + ShardGroupID *uint64 `protobuf:"varint,3,req,name=ShardGroupID" json:"ShardGroupID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteShardGroupCommand) Reset() { *m = DeleteShardGroupCommand{} } +func (m *DeleteShardGroupCommand) String() string { return proto.CompactTextString(m) } +func (*DeleteShardGroupCommand) ProtoMessage() {} +func (*DeleteShardGroupCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{22} +} +func (m *DeleteShardGroupCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DeleteShardGroupCommand.Unmarshal(m, b) +} +func (m *DeleteShardGroupCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DeleteShardGroupCommand.Marshal(b, m, deterministic) +} +func (m *DeleteShardGroupCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteShardGroupCommand.Merge(m, src) +} +func (m *DeleteShardGroupCommand) XXX_Size() int { + return xxx_messageInfo_DeleteShardGroupCommand.Size(m) +} +func (m *DeleteShardGroupCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteShardGroupCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DeleteShardGroupCommand proto.InternalMessageInfo + +func (m *DeleteShardGroupCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *DeleteShardGroupCommand) GetPolicy() string { + if m != nil && m.Policy != nil { + return *m.Policy + } + return "" +} + +func (m *DeleteShardGroupCommand) GetShardGroupID() uint64 { + if m != nil && m.ShardGroupID != nil { + return *m.ShardGroupID + } + return 0 +} + +var E_DeleteShardGroupCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DeleteShardGroupCommand)(nil), + Field: 110, + Name: "internal.DeleteShardGroupCommand.command", + Tag: "bytes,110,opt,name=command", + Filename: "internal/meta.proto", +} + +type CreateContinuousQueryCommand struct { + Database *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"` + Name *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"` + Query *string `protobuf:"bytes,3,req,name=Query" json:"Query,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreateContinuousQueryCommand) Reset() { *m = CreateContinuousQueryCommand{} } +func (m *CreateContinuousQueryCommand) String() string { return proto.CompactTextString(m) } +func (*CreateContinuousQueryCommand) ProtoMessage() {} +func (*CreateContinuousQueryCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{23} +} +func (m *CreateContinuousQueryCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreateContinuousQueryCommand.Unmarshal(m, b) +} +func (m *CreateContinuousQueryCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreateContinuousQueryCommand.Marshal(b, m, deterministic) +} +func (m *CreateContinuousQueryCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreateContinuousQueryCommand.Merge(m, src) +} +func (m *CreateContinuousQueryCommand) XXX_Size() int { + return xxx_messageInfo_CreateContinuousQueryCommand.Size(m) +} +func (m *CreateContinuousQueryCommand) XXX_DiscardUnknown() { + xxx_messageInfo_CreateContinuousQueryCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_CreateContinuousQueryCommand proto.InternalMessageInfo + +func (m *CreateContinuousQueryCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *CreateContinuousQueryCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CreateContinuousQueryCommand) GetQuery() string { + if m != nil && m.Query != nil { + return *m.Query + } + return "" +} + +var E_CreateContinuousQueryCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*CreateContinuousQueryCommand)(nil), + Field: 111, + Name: "internal.CreateContinuousQueryCommand.command", + Tag: "bytes,111,opt,name=command", + Filename: "internal/meta.proto", +} + +type DropContinuousQueryCommand struct { + Database *string `protobuf:"bytes,1,req,name=Database" json:"Database,omitempty"` + Name *string `protobuf:"bytes,2,req,name=Name" json:"Name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DropContinuousQueryCommand) Reset() { *m = DropContinuousQueryCommand{} } +func (m *DropContinuousQueryCommand) String() string { return proto.CompactTextString(m) } +func (*DropContinuousQueryCommand) ProtoMessage() {} +func (*DropContinuousQueryCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{24} +} +func (m *DropContinuousQueryCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DropContinuousQueryCommand.Unmarshal(m, b) +} +func (m *DropContinuousQueryCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DropContinuousQueryCommand.Marshal(b, m, deterministic) +} +func (m *DropContinuousQueryCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DropContinuousQueryCommand.Merge(m, src) +} +func (m *DropContinuousQueryCommand) XXX_Size() int { + return xxx_messageInfo_DropContinuousQueryCommand.Size(m) +} +func (m *DropContinuousQueryCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DropContinuousQueryCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DropContinuousQueryCommand proto.InternalMessageInfo + +func (m *DropContinuousQueryCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *DropContinuousQueryCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +var E_DropContinuousQueryCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DropContinuousQueryCommand)(nil), + Field: 112, + Name: "internal.DropContinuousQueryCommand.command", + Tag: "bytes,112,opt,name=command", + Filename: "internal/meta.proto", +} + +type CreateUserCommand struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + Hash *string `protobuf:"bytes,2,req,name=Hash" json:"Hash,omitempty"` + Admin *bool `protobuf:"varint,3,req,name=Admin" json:"Admin,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreateUserCommand) Reset() { *m = CreateUserCommand{} } +func (m *CreateUserCommand) String() string { return proto.CompactTextString(m) } +func (*CreateUserCommand) ProtoMessage() {} +func (*CreateUserCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{25} +} +func (m *CreateUserCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreateUserCommand.Unmarshal(m, b) +} +func (m *CreateUserCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreateUserCommand.Marshal(b, m, deterministic) +} +func (m *CreateUserCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreateUserCommand.Merge(m, src) +} +func (m *CreateUserCommand) XXX_Size() int { + return xxx_messageInfo_CreateUserCommand.Size(m) +} +func (m *CreateUserCommand) XXX_DiscardUnknown() { + xxx_messageInfo_CreateUserCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_CreateUserCommand proto.InternalMessageInfo + +func (m *CreateUserCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CreateUserCommand) GetHash() string { + if m != nil && m.Hash != nil { + return *m.Hash + } + return "" +} + +func (m *CreateUserCommand) GetAdmin() bool { + if m != nil && m.Admin != nil { + return *m.Admin + } + return false +} + +var E_CreateUserCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*CreateUserCommand)(nil), + Field: 113, + Name: "internal.CreateUserCommand.command", + Tag: "bytes,113,opt,name=command", + Filename: "internal/meta.proto", +} + +type DropUserCommand struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DropUserCommand) Reset() { *m = DropUserCommand{} } +func (m *DropUserCommand) String() string { return proto.CompactTextString(m) } +func (*DropUserCommand) ProtoMessage() {} +func (*DropUserCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{26} +} +func (m *DropUserCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DropUserCommand.Unmarshal(m, b) +} +func (m *DropUserCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DropUserCommand.Marshal(b, m, deterministic) +} +func (m *DropUserCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DropUserCommand.Merge(m, src) +} +func (m *DropUserCommand) XXX_Size() int { + return xxx_messageInfo_DropUserCommand.Size(m) +} +func (m *DropUserCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DropUserCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DropUserCommand proto.InternalMessageInfo + +func (m *DropUserCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +var E_DropUserCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DropUserCommand)(nil), + Field: 114, + Name: "internal.DropUserCommand.command", + Tag: "bytes,114,opt,name=command", + Filename: "internal/meta.proto", +} + +type UpdateUserCommand struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + Hash *string `protobuf:"bytes,2,req,name=Hash" json:"Hash,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateUserCommand) Reset() { *m = UpdateUserCommand{} } +func (m *UpdateUserCommand) String() string { return proto.CompactTextString(m) } +func (*UpdateUserCommand) ProtoMessage() {} +func (*UpdateUserCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{27} +} +func (m *UpdateUserCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UpdateUserCommand.Unmarshal(m, b) +} +func (m *UpdateUserCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UpdateUserCommand.Marshal(b, m, deterministic) +} +func (m *UpdateUserCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateUserCommand.Merge(m, src) +} +func (m *UpdateUserCommand) XXX_Size() int { + return xxx_messageInfo_UpdateUserCommand.Size(m) +} +func (m *UpdateUserCommand) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateUserCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateUserCommand proto.InternalMessageInfo + +func (m *UpdateUserCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *UpdateUserCommand) GetHash() string { + if m != nil && m.Hash != nil { + return *m.Hash + } + return "" +} + +var E_UpdateUserCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*UpdateUserCommand)(nil), + Field: 115, + Name: "internal.UpdateUserCommand.command", + Tag: "bytes,115,opt,name=command", + Filename: "internal/meta.proto", +} + +type SetPrivilegeCommand struct { + Username *string `protobuf:"bytes,1,req,name=Username" json:"Username,omitempty"` + Database *string `protobuf:"bytes,2,req,name=Database" json:"Database,omitempty"` + Privilege *int32 `protobuf:"varint,3,req,name=Privilege" json:"Privilege,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SetPrivilegeCommand) Reset() { *m = SetPrivilegeCommand{} } +func (m *SetPrivilegeCommand) String() string { return proto.CompactTextString(m) } +func (*SetPrivilegeCommand) ProtoMessage() {} +func (*SetPrivilegeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{28} +} +func (m *SetPrivilegeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SetPrivilegeCommand.Unmarshal(m, b) +} +func (m *SetPrivilegeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SetPrivilegeCommand.Marshal(b, m, deterministic) +} +func (m *SetPrivilegeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetPrivilegeCommand.Merge(m, src) +} +func (m *SetPrivilegeCommand) XXX_Size() int { + return xxx_messageInfo_SetPrivilegeCommand.Size(m) +} +func (m *SetPrivilegeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_SetPrivilegeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_SetPrivilegeCommand proto.InternalMessageInfo + +func (m *SetPrivilegeCommand) GetUsername() string { + if m != nil && m.Username != nil { + return *m.Username + } + return "" +} + +func (m *SetPrivilegeCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *SetPrivilegeCommand) GetPrivilege() int32 { + if m != nil && m.Privilege != nil { + return *m.Privilege + } + return 0 +} + +var E_SetPrivilegeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*SetPrivilegeCommand)(nil), + Field: 116, + Name: "internal.SetPrivilegeCommand.command", + Tag: "bytes,116,opt,name=command", + Filename: "internal/meta.proto", +} + +type SetDataCommand struct { + Data *Data `protobuf:"bytes,1,req,name=Data" json:"Data,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SetDataCommand) Reset() { *m = SetDataCommand{} } +func (m *SetDataCommand) String() string { return proto.CompactTextString(m) } +func (*SetDataCommand) ProtoMessage() {} +func (*SetDataCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{29} +} +func (m *SetDataCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SetDataCommand.Unmarshal(m, b) +} +func (m *SetDataCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SetDataCommand.Marshal(b, m, deterministic) +} +func (m *SetDataCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetDataCommand.Merge(m, src) +} +func (m *SetDataCommand) XXX_Size() int { + return xxx_messageInfo_SetDataCommand.Size(m) +} +func (m *SetDataCommand) XXX_DiscardUnknown() { + xxx_messageInfo_SetDataCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_SetDataCommand proto.InternalMessageInfo + +func (m *SetDataCommand) GetData() *Data { + if m != nil { + return m.Data + } + return nil +} + +var E_SetDataCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*SetDataCommand)(nil), + Field: 117, + Name: "internal.SetDataCommand.command", + Tag: "bytes,117,opt,name=command", + Filename: "internal/meta.proto", +} + +type SetAdminPrivilegeCommand struct { + Username *string `protobuf:"bytes,1,req,name=Username" json:"Username,omitempty"` + Admin *bool `protobuf:"varint,2,req,name=Admin" json:"Admin,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SetAdminPrivilegeCommand) Reset() { *m = SetAdminPrivilegeCommand{} } +func (m *SetAdminPrivilegeCommand) String() string { return proto.CompactTextString(m) } +func (*SetAdminPrivilegeCommand) ProtoMessage() {} +func (*SetAdminPrivilegeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{30} +} +func (m *SetAdminPrivilegeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SetAdminPrivilegeCommand.Unmarshal(m, b) +} +func (m *SetAdminPrivilegeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SetAdminPrivilegeCommand.Marshal(b, m, deterministic) +} +func (m *SetAdminPrivilegeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetAdminPrivilegeCommand.Merge(m, src) +} +func (m *SetAdminPrivilegeCommand) XXX_Size() int { + return xxx_messageInfo_SetAdminPrivilegeCommand.Size(m) +} +func (m *SetAdminPrivilegeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_SetAdminPrivilegeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_SetAdminPrivilegeCommand proto.InternalMessageInfo + +func (m *SetAdminPrivilegeCommand) GetUsername() string { + if m != nil && m.Username != nil { + return *m.Username + } + return "" +} + +func (m *SetAdminPrivilegeCommand) GetAdmin() bool { + if m != nil && m.Admin != nil { + return *m.Admin + } + return false +} + +var E_SetAdminPrivilegeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*SetAdminPrivilegeCommand)(nil), + Field: 118, + Name: "internal.SetAdminPrivilegeCommand.command", + Tag: "bytes,118,opt,name=command", + Filename: "internal/meta.proto", +} + +type UpdateNodeCommand struct { + ID *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"` + Host *string `protobuf:"bytes,2,req,name=Host" json:"Host,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateNodeCommand) Reset() { *m = UpdateNodeCommand{} } +func (m *UpdateNodeCommand) String() string { return proto.CompactTextString(m) } +func (*UpdateNodeCommand) ProtoMessage() {} +func (*UpdateNodeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{31} +} +func (m *UpdateNodeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UpdateNodeCommand.Unmarshal(m, b) +} +func (m *UpdateNodeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UpdateNodeCommand.Marshal(b, m, deterministic) +} +func (m *UpdateNodeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateNodeCommand.Merge(m, src) +} +func (m *UpdateNodeCommand) XXX_Size() int { + return xxx_messageInfo_UpdateNodeCommand.Size(m) +} +func (m *UpdateNodeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateNodeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateNodeCommand proto.InternalMessageInfo + +func (m *UpdateNodeCommand) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +func (m *UpdateNodeCommand) GetHost() string { + if m != nil && m.Host != nil { + return *m.Host + } + return "" +} + +var E_UpdateNodeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*UpdateNodeCommand)(nil), + Field: 119, + Name: "internal.UpdateNodeCommand.command", + Tag: "bytes,119,opt,name=command", + Filename: "internal/meta.proto", +} + +type CreateSubscriptionCommand struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + Database *string `protobuf:"bytes,2,req,name=Database" json:"Database,omitempty"` + RetentionPolicy *string `protobuf:"bytes,3,req,name=RetentionPolicy" json:"RetentionPolicy,omitempty"` + Mode *string `protobuf:"bytes,4,req,name=Mode" json:"Mode,omitempty"` + Destinations []string `protobuf:"bytes,5,rep,name=Destinations" json:"Destinations,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreateSubscriptionCommand) Reset() { *m = CreateSubscriptionCommand{} } +func (m *CreateSubscriptionCommand) String() string { return proto.CompactTextString(m) } +func (*CreateSubscriptionCommand) ProtoMessage() {} +func (*CreateSubscriptionCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{32} +} +func (m *CreateSubscriptionCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreateSubscriptionCommand.Unmarshal(m, b) +} +func (m *CreateSubscriptionCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreateSubscriptionCommand.Marshal(b, m, deterministic) +} +func (m *CreateSubscriptionCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreateSubscriptionCommand.Merge(m, src) +} +func (m *CreateSubscriptionCommand) XXX_Size() int { + return xxx_messageInfo_CreateSubscriptionCommand.Size(m) +} +func (m *CreateSubscriptionCommand) XXX_DiscardUnknown() { + xxx_messageInfo_CreateSubscriptionCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_CreateSubscriptionCommand proto.InternalMessageInfo + +func (m *CreateSubscriptionCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *CreateSubscriptionCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *CreateSubscriptionCommand) GetRetentionPolicy() string { + if m != nil && m.RetentionPolicy != nil { + return *m.RetentionPolicy + } + return "" +} + +func (m *CreateSubscriptionCommand) GetMode() string { + if m != nil && m.Mode != nil { + return *m.Mode + } + return "" +} + +func (m *CreateSubscriptionCommand) GetDestinations() []string { + if m != nil { + return m.Destinations + } + return nil +} + +var E_CreateSubscriptionCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*CreateSubscriptionCommand)(nil), + Field: 121, + Name: "internal.CreateSubscriptionCommand.command", + Tag: "bytes,121,opt,name=command", + Filename: "internal/meta.proto", +} + +type DropSubscriptionCommand struct { + Name *string `protobuf:"bytes,1,req,name=Name" json:"Name,omitempty"` + Database *string `protobuf:"bytes,2,req,name=Database" json:"Database,omitempty"` + RetentionPolicy *string `protobuf:"bytes,3,req,name=RetentionPolicy" json:"RetentionPolicy,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DropSubscriptionCommand) Reset() { *m = DropSubscriptionCommand{} } +func (m *DropSubscriptionCommand) String() string { return proto.CompactTextString(m) } +func (*DropSubscriptionCommand) ProtoMessage() {} +func (*DropSubscriptionCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{33} +} +func (m *DropSubscriptionCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DropSubscriptionCommand.Unmarshal(m, b) +} +func (m *DropSubscriptionCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DropSubscriptionCommand.Marshal(b, m, deterministic) +} +func (m *DropSubscriptionCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DropSubscriptionCommand.Merge(m, src) +} +func (m *DropSubscriptionCommand) XXX_Size() int { + return xxx_messageInfo_DropSubscriptionCommand.Size(m) +} +func (m *DropSubscriptionCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DropSubscriptionCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DropSubscriptionCommand proto.InternalMessageInfo + +func (m *DropSubscriptionCommand) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *DropSubscriptionCommand) GetDatabase() string { + if m != nil && m.Database != nil { + return *m.Database + } + return "" +} + +func (m *DropSubscriptionCommand) GetRetentionPolicy() string { + if m != nil && m.RetentionPolicy != nil { + return *m.RetentionPolicy + } + return "" +} + +var E_DropSubscriptionCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DropSubscriptionCommand)(nil), + Field: 122, + Name: "internal.DropSubscriptionCommand.command", + Tag: "bytes,122,opt,name=command", + Filename: "internal/meta.proto", +} + +type RemovePeerCommand struct { + ID *uint64 `protobuf:"varint,1,opt,name=ID" json:"ID,omitempty"` + Addr *string `protobuf:"bytes,2,req,name=Addr" json:"Addr,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RemovePeerCommand) Reset() { *m = RemovePeerCommand{} } +func (m *RemovePeerCommand) String() string { return proto.CompactTextString(m) } +func (*RemovePeerCommand) ProtoMessage() {} +func (*RemovePeerCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{34} +} +func (m *RemovePeerCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_RemovePeerCommand.Unmarshal(m, b) +} +func (m *RemovePeerCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_RemovePeerCommand.Marshal(b, m, deterministic) +} +func (m *RemovePeerCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_RemovePeerCommand.Merge(m, src) +} +func (m *RemovePeerCommand) XXX_Size() int { + return xxx_messageInfo_RemovePeerCommand.Size(m) +} +func (m *RemovePeerCommand) XXX_DiscardUnknown() { + xxx_messageInfo_RemovePeerCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_RemovePeerCommand proto.InternalMessageInfo + +func (m *RemovePeerCommand) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +func (m *RemovePeerCommand) GetAddr() string { + if m != nil && m.Addr != nil { + return *m.Addr + } + return "" +} + +var E_RemovePeerCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*RemovePeerCommand)(nil), + Field: 123, + Name: "internal.RemovePeerCommand.command", + Tag: "bytes,123,opt,name=command", + Filename: "internal/meta.proto", +} + +type CreateMetaNodeCommand struct { + HTTPAddr *string `protobuf:"bytes,1,req,name=HTTPAddr" json:"HTTPAddr,omitempty"` + TCPAddr *string `protobuf:"bytes,2,req,name=TCPAddr" json:"TCPAddr,omitempty"` + Rand *uint64 `protobuf:"varint,3,req,name=Rand" json:"Rand,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreateMetaNodeCommand) Reset() { *m = CreateMetaNodeCommand{} } +func (m *CreateMetaNodeCommand) String() string { return proto.CompactTextString(m) } +func (*CreateMetaNodeCommand) ProtoMessage() {} +func (*CreateMetaNodeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{35} +} +func (m *CreateMetaNodeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreateMetaNodeCommand.Unmarshal(m, b) +} +func (m *CreateMetaNodeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreateMetaNodeCommand.Marshal(b, m, deterministic) +} +func (m *CreateMetaNodeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreateMetaNodeCommand.Merge(m, src) +} +func (m *CreateMetaNodeCommand) XXX_Size() int { + return xxx_messageInfo_CreateMetaNodeCommand.Size(m) +} +func (m *CreateMetaNodeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_CreateMetaNodeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_CreateMetaNodeCommand proto.InternalMessageInfo + +func (m *CreateMetaNodeCommand) GetHTTPAddr() string { + if m != nil && m.HTTPAddr != nil { + return *m.HTTPAddr + } + return "" +} + +func (m *CreateMetaNodeCommand) GetTCPAddr() string { + if m != nil && m.TCPAddr != nil { + return *m.TCPAddr + } + return "" +} + +func (m *CreateMetaNodeCommand) GetRand() uint64 { + if m != nil && m.Rand != nil { + return *m.Rand + } + return 0 +} + +var E_CreateMetaNodeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*CreateMetaNodeCommand)(nil), + Field: 124, + Name: "internal.CreateMetaNodeCommand.command", + Tag: "bytes,124,opt,name=command", + Filename: "internal/meta.proto", +} + +type CreateDataNodeCommand struct { + HTTPAddr *string `protobuf:"bytes,1,req,name=HTTPAddr" json:"HTTPAddr,omitempty"` + TCPAddr *string `protobuf:"bytes,2,req,name=TCPAddr" json:"TCPAddr,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *CreateDataNodeCommand) Reset() { *m = CreateDataNodeCommand{} } +func (m *CreateDataNodeCommand) String() string { return proto.CompactTextString(m) } +func (*CreateDataNodeCommand) ProtoMessage() {} +func (*CreateDataNodeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{36} +} +func (m *CreateDataNodeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_CreateDataNodeCommand.Unmarshal(m, b) +} +func (m *CreateDataNodeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_CreateDataNodeCommand.Marshal(b, m, deterministic) +} +func (m *CreateDataNodeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_CreateDataNodeCommand.Merge(m, src) +} +func (m *CreateDataNodeCommand) XXX_Size() int { + return xxx_messageInfo_CreateDataNodeCommand.Size(m) +} +func (m *CreateDataNodeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_CreateDataNodeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_CreateDataNodeCommand proto.InternalMessageInfo + +func (m *CreateDataNodeCommand) GetHTTPAddr() string { + if m != nil && m.HTTPAddr != nil { + return *m.HTTPAddr + } + return "" +} + +func (m *CreateDataNodeCommand) GetTCPAddr() string { + if m != nil && m.TCPAddr != nil { + return *m.TCPAddr + } + return "" +} + +var E_CreateDataNodeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*CreateDataNodeCommand)(nil), + Field: 125, + Name: "internal.CreateDataNodeCommand.command", + Tag: "bytes,125,opt,name=command", + Filename: "internal/meta.proto", +} + +type UpdateDataNodeCommand struct { + ID *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"` + Host *string `protobuf:"bytes,2,req,name=Host" json:"Host,omitempty"` + TCPHost *string `protobuf:"bytes,3,req,name=TCPHost" json:"TCPHost,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *UpdateDataNodeCommand) Reset() { *m = UpdateDataNodeCommand{} } +func (m *UpdateDataNodeCommand) String() string { return proto.CompactTextString(m) } +func (*UpdateDataNodeCommand) ProtoMessage() {} +func (*UpdateDataNodeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{37} +} +func (m *UpdateDataNodeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_UpdateDataNodeCommand.Unmarshal(m, b) +} +func (m *UpdateDataNodeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_UpdateDataNodeCommand.Marshal(b, m, deterministic) +} +func (m *UpdateDataNodeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_UpdateDataNodeCommand.Merge(m, src) +} +func (m *UpdateDataNodeCommand) XXX_Size() int { + return xxx_messageInfo_UpdateDataNodeCommand.Size(m) +} +func (m *UpdateDataNodeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_UpdateDataNodeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_UpdateDataNodeCommand proto.InternalMessageInfo + +func (m *UpdateDataNodeCommand) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +func (m *UpdateDataNodeCommand) GetHost() string { + if m != nil && m.Host != nil { + return *m.Host + } + return "" +} + +func (m *UpdateDataNodeCommand) GetTCPHost() string { + if m != nil && m.TCPHost != nil { + return *m.TCPHost + } + return "" +} + +var E_UpdateDataNodeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*UpdateDataNodeCommand)(nil), + Field: 126, + Name: "internal.UpdateDataNodeCommand.command", + Tag: "bytes,126,opt,name=command", + Filename: "internal/meta.proto", +} + +type DeleteMetaNodeCommand struct { + ID *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteMetaNodeCommand) Reset() { *m = DeleteMetaNodeCommand{} } +func (m *DeleteMetaNodeCommand) String() string { return proto.CompactTextString(m) } +func (*DeleteMetaNodeCommand) ProtoMessage() {} +func (*DeleteMetaNodeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{38} +} +func (m *DeleteMetaNodeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DeleteMetaNodeCommand.Unmarshal(m, b) +} +func (m *DeleteMetaNodeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DeleteMetaNodeCommand.Marshal(b, m, deterministic) +} +func (m *DeleteMetaNodeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteMetaNodeCommand.Merge(m, src) +} +func (m *DeleteMetaNodeCommand) XXX_Size() int { + return xxx_messageInfo_DeleteMetaNodeCommand.Size(m) +} +func (m *DeleteMetaNodeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteMetaNodeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DeleteMetaNodeCommand proto.InternalMessageInfo + +func (m *DeleteMetaNodeCommand) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +var E_DeleteMetaNodeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DeleteMetaNodeCommand)(nil), + Field: 127, + Name: "internal.DeleteMetaNodeCommand.command", + Tag: "bytes,127,opt,name=command", + Filename: "internal/meta.proto", +} + +type DeleteDataNodeCommand struct { + ID *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DeleteDataNodeCommand) Reset() { *m = DeleteDataNodeCommand{} } +func (m *DeleteDataNodeCommand) String() string { return proto.CompactTextString(m) } +func (*DeleteDataNodeCommand) ProtoMessage() {} +func (*DeleteDataNodeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{39} +} +func (m *DeleteDataNodeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DeleteDataNodeCommand.Unmarshal(m, b) +} +func (m *DeleteDataNodeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DeleteDataNodeCommand.Marshal(b, m, deterministic) +} +func (m *DeleteDataNodeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DeleteDataNodeCommand.Merge(m, src) +} +func (m *DeleteDataNodeCommand) XXX_Size() int { + return xxx_messageInfo_DeleteDataNodeCommand.Size(m) +} +func (m *DeleteDataNodeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DeleteDataNodeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DeleteDataNodeCommand proto.InternalMessageInfo + +func (m *DeleteDataNodeCommand) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +var E_DeleteDataNodeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DeleteDataNodeCommand)(nil), + Field: 128, + Name: "internal.DeleteDataNodeCommand.command", + Tag: "bytes,128,opt,name=command", + Filename: "internal/meta.proto", +} + +type Response struct { + OK *bool `protobuf:"varint,1,req,name=OK" json:"OK,omitempty"` + Error *string `protobuf:"bytes,2,opt,name=Error" json:"Error,omitempty"` + Index *uint64 `protobuf:"varint,3,opt,name=Index" json:"Index,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Response) Reset() { *m = Response{} } +func (m *Response) String() string { return proto.CompactTextString(m) } +func (*Response) ProtoMessage() {} +func (*Response) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{40} +} +func (m *Response) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Response.Unmarshal(m, b) +} +func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Response.Marshal(b, m, deterministic) +} +func (m *Response) XXX_Merge(src proto.Message) { + xxx_messageInfo_Response.Merge(m, src) +} +func (m *Response) XXX_Size() int { + return xxx_messageInfo_Response.Size(m) +} +func (m *Response) XXX_DiscardUnknown() { + xxx_messageInfo_Response.DiscardUnknown(m) +} + +var xxx_messageInfo_Response proto.InternalMessageInfo + +func (m *Response) GetOK() bool { + if m != nil && m.OK != nil { + return *m.OK + } + return false +} + +func (m *Response) GetError() string { + if m != nil && m.Error != nil { + return *m.Error + } + return "" +} + +func (m *Response) GetIndex() uint64 { + if m != nil && m.Index != nil { + return *m.Index + } + return 0 +} + +// SetMetaNodeCommand is for the initial metanode in a cluster or +// if the single host restarts and its hostname changes, this will update it +type SetMetaNodeCommand struct { + HTTPAddr *string `protobuf:"bytes,1,req,name=HTTPAddr" json:"HTTPAddr,omitempty"` + TCPAddr *string `protobuf:"bytes,2,req,name=TCPAddr" json:"TCPAddr,omitempty"` + Rand *uint64 `protobuf:"varint,3,req,name=Rand" json:"Rand,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SetMetaNodeCommand) Reset() { *m = SetMetaNodeCommand{} } +func (m *SetMetaNodeCommand) String() string { return proto.CompactTextString(m) } +func (*SetMetaNodeCommand) ProtoMessage() {} +func (*SetMetaNodeCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{41} +} +func (m *SetMetaNodeCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_SetMetaNodeCommand.Unmarshal(m, b) +} +func (m *SetMetaNodeCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_SetMetaNodeCommand.Marshal(b, m, deterministic) +} +func (m *SetMetaNodeCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_SetMetaNodeCommand.Merge(m, src) +} +func (m *SetMetaNodeCommand) XXX_Size() int { + return xxx_messageInfo_SetMetaNodeCommand.Size(m) +} +func (m *SetMetaNodeCommand) XXX_DiscardUnknown() { + xxx_messageInfo_SetMetaNodeCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_SetMetaNodeCommand proto.InternalMessageInfo + +func (m *SetMetaNodeCommand) GetHTTPAddr() string { + if m != nil && m.HTTPAddr != nil { + return *m.HTTPAddr + } + return "" +} + +func (m *SetMetaNodeCommand) GetTCPAddr() string { + if m != nil && m.TCPAddr != nil { + return *m.TCPAddr + } + return "" +} + +func (m *SetMetaNodeCommand) GetRand() uint64 { + if m != nil && m.Rand != nil { + return *m.Rand + } + return 0 +} + +var E_SetMetaNodeCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*SetMetaNodeCommand)(nil), + Field: 129, + Name: "internal.SetMetaNodeCommand.command", + Tag: "bytes,129,opt,name=command", + Filename: "internal/meta.proto", +} + +type DropShardCommand struct { + ID *uint64 `protobuf:"varint,1,req,name=ID" json:"ID,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *DropShardCommand) Reset() { *m = DropShardCommand{} } +func (m *DropShardCommand) String() string { return proto.CompactTextString(m) } +func (*DropShardCommand) ProtoMessage() {} +func (*DropShardCommand) Descriptor() ([]byte, []int) { + return fileDescriptor_59b0956366e72083, []int{42} +} +func (m *DropShardCommand) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_DropShardCommand.Unmarshal(m, b) +} +func (m *DropShardCommand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_DropShardCommand.Marshal(b, m, deterministic) +} +func (m *DropShardCommand) XXX_Merge(src proto.Message) { + xxx_messageInfo_DropShardCommand.Merge(m, src) +} +func (m *DropShardCommand) XXX_Size() int { + return xxx_messageInfo_DropShardCommand.Size(m) +} +func (m *DropShardCommand) XXX_DiscardUnknown() { + xxx_messageInfo_DropShardCommand.DiscardUnknown(m) +} + +var xxx_messageInfo_DropShardCommand proto.InternalMessageInfo + +func (m *DropShardCommand) GetID() uint64 { + if m != nil && m.ID != nil { + return *m.ID + } + return 0 +} + +var E_DropShardCommand_Command = &proto.ExtensionDesc{ + ExtendedType: (*Command)(nil), + ExtensionType: (*DropShardCommand)(nil), + Field: 130, + Name: "internal.DropShardCommand.command", + Tag: "bytes,130,opt,name=command", + Filename: "internal/meta.proto", +} + +func init() { + proto.RegisterEnum("internal.Command_Type", Command_Type_name, Command_Type_value) + proto.RegisterType((*Data)(nil), "internal.Data") + proto.RegisterType((*NodeInfo)(nil), "internal.NodeInfo") + proto.RegisterType((*DatabaseInfo)(nil), "internal.DatabaseInfo") + proto.RegisterType((*RetentionPolicySpec)(nil), "internal.RetentionPolicySpec") + proto.RegisterType((*RetentionPolicyInfo)(nil), "internal.RetentionPolicyInfo") + proto.RegisterType((*ShardGroupInfo)(nil), "internal.ShardGroupInfo") + proto.RegisterType((*ShardInfo)(nil), "internal.ShardInfo") + proto.RegisterType((*SubscriptionInfo)(nil), "internal.SubscriptionInfo") + proto.RegisterType((*ShardOwner)(nil), "internal.ShardOwner") + proto.RegisterType((*ContinuousQueryInfo)(nil), "internal.ContinuousQueryInfo") + proto.RegisterType((*UserInfo)(nil), "internal.UserInfo") + proto.RegisterType((*UserPrivilege)(nil), "internal.UserPrivilege") + proto.RegisterType((*Command)(nil), "internal.Command") + proto.RegisterExtension(E_CreateNodeCommand_Command) + proto.RegisterType((*CreateNodeCommand)(nil), "internal.CreateNodeCommand") + proto.RegisterExtension(E_DeleteNodeCommand_Command) + proto.RegisterType((*DeleteNodeCommand)(nil), "internal.DeleteNodeCommand") + proto.RegisterExtension(E_CreateDatabaseCommand_Command) + proto.RegisterType((*CreateDatabaseCommand)(nil), "internal.CreateDatabaseCommand") + proto.RegisterExtension(E_DropDatabaseCommand_Command) + proto.RegisterType((*DropDatabaseCommand)(nil), "internal.DropDatabaseCommand") + proto.RegisterExtension(E_CreateRetentionPolicyCommand_Command) + proto.RegisterType((*CreateRetentionPolicyCommand)(nil), "internal.CreateRetentionPolicyCommand") + proto.RegisterExtension(E_DropRetentionPolicyCommand_Command) + proto.RegisterType((*DropRetentionPolicyCommand)(nil), "internal.DropRetentionPolicyCommand") + proto.RegisterExtension(E_SetDefaultRetentionPolicyCommand_Command) + proto.RegisterType((*SetDefaultRetentionPolicyCommand)(nil), "internal.SetDefaultRetentionPolicyCommand") + proto.RegisterExtension(E_UpdateRetentionPolicyCommand_Command) + proto.RegisterType((*UpdateRetentionPolicyCommand)(nil), "internal.UpdateRetentionPolicyCommand") + proto.RegisterExtension(E_CreateShardGroupCommand_Command) + proto.RegisterType((*CreateShardGroupCommand)(nil), "internal.CreateShardGroupCommand") + proto.RegisterExtension(E_DeleteShardGroupCommand_Command) + proto.RegisterType((*DeleteShardGroupCommand)(nil), "internal.DeleteShardGroupCommand") + proto.RegisterExtension(E_CreateContinuousQueryCommand_Command) + proto.RegisterType((*CreateContinuousQueryCommand)(nil), "internal.CreateContinuousQueryCommand") + proto.RegisterExtension(E_DropContinuousQueryCommand_Command) + proto.RegisterType((*DropContinuousQueryCommand)(nil), "internal.DropContinuousQueryCommand") + proto.RegisterExtension(E_CreateUserCommand_Command) + proto.RegisterType((*CreateUserCommand)(nil), "internal.CreateUserCommand") + proto.RegisterExtension(E_DropUserCommand_Command) + proto.RegisterType((*DropUserCommand)(nil), "internal.DropUserCommand") + proto.RegisterExtension(E_UpdateUserCommand_Command) + proto.RegisterType((*UpdateUserCommand)(nil), "internal.UpdateUserCommand") + proto.RegisterExtension(E_SetPrivilegeCommand_Command) + proto.RegisterType((*SetPrivilegeCommand)(nil), "internal.SetPrivilegeCommand") + proto.RegisterExtension(E_SetDataCommand_Command) + proto.RegisterType((*SetDataCommand)(nil), "internal.SetDataCommand") + proto.RegisterExtension(E_SetAdminPrivilegeCommand_Command) + proto.RegisterType((*SetAdminPrivilegeCommand)(nil), "internal.SetAdminPrivilegeCommand") + proto.RegisterExtension(E_UpdateNodeCommand_Command) + proto.RegisterType((*UpdateNodeCommand)(nil), "internal.UpdateNodeCommand") + proto.RegisterExtension(E_CreateSubscriptionCommand_Command) + proto.RegisterType((*CreateSubscriptionCommand)(nil), "internal.CreateSubscriptionCommand") + proto.RegisterExtension(E_DropSubscriptionCommand_Command) + proto.RegisterType((*DropSubscriptionCommand)(nil), "internal.DropSubscriptionCommand") + proto.RegisterExtension(E_RemovePeerCommand_Command) + proto.RegisterType((*RemovePeerCommand)(nil), "internal.RemovePeerCommand") + proto.RegisterExtension(E_CreateMetaNodeCommand_Command) + proto.RegisterType((*CreateMetaNodeCommand)(nil), "internal.CreateMetaNodeCommand") + proto.RegisterExtension(E_CreateDataNodeCommand_Command) + proto.RegisterType((*CreateDataNodeCommand)(nil), "internal.CreateDataNodeCommand") + proto.RegisterExtension(E_UpdateDataNodeCommand_Command) + proto.RegisterType((*UpdateDataNodeCommand)(nil), "internal.UpdateDataNodeCommand") + proto.RegisterExtension(E_DeleteMetaNodeCommand_Command) + proto.RegisterType((*DeleteMetaNodeCommand)(nil), "internal.DeleteMetaNodeCommand") + proto.RegisterExtension(E_DeleteDataNodeCommand_Command) + proto.RegisterType((*DeleteDataNodeCommand)(nil), "internal.DeleteDataNodeCommand") + proto.RegisterType((*Response)(nil), "internal.Response") + proto.RegisterExtension(E_SetMetaNodeCommand_Command) + proto.RegisterType((*SetMetaNodeCommand)(nil), "internal.SetMetaNodeCommand") + proto.RegisterExtension(E_DropShardCommand_Command) + proto.RegisterType((*DropShardCommand)(nil), "internal.DropShardCommand") +} + +func init() { proto.RegisterFile("internal/meta.proto", fileDescriptor_59b0956366e72083) } + +var fileDescriptor_59b0956366e72083 = []byte{ + // 1826 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x59, 0xcd, 0x6f, 0xdc, 0xc6, + 0x15, 0xc7, 0x70, 0x3f, 0xb4, 0xfb, 0xf4, 0x3d, 0x92, 0x25, 0x4a, 0x96, 0xd5, 0x2d, 0x6b, 0x14, + 0x0b, 0xb7, 0x50, 0x8b, 0x45, 0xd1, 0x02, 0xbd, 0xb4, 0xae, 0xd6, 0xb6, 0xb6, 0xae, 0x3e, 0xcc, + 0x95, 0xd1, 0x5b, 0x01, 0x5a, 0x3b, 0xb6, 0xb6, 0xdd, 0x25, 0xb7, 0x24, 0x57, 0xb6, 0xea, 0x7e, + 0xc8, 0x0d, 0x72, 0x0e, 0x72, 0x36, 0x82, 0x1c, 0x92, 0x53, 0x72, 0xc8, 0x31, 0x08, 0x72, 0x4a, + 0x82, 0xfc, 0x0f, 0xb9, 0xe4, 0xbf, 0x48, 0xce, 0x09, 0x66, 0xc8, 0xe1, 0x0c, 0x87, 0x43, 0x52, + 0x72, 0x9c, 0xdb, 0xce, 0xfb, 0x98, 0xf7, 0xfb, 0x3d, 0xbe, 0x99, 0x79, 0x33, 0x0b, 0x2b, 0x43, + 0x37, 0x24, 0xbe, 0xeb, 0x8c, 0x7e, 0x35, 0x26, 0xa1, 0xb3, 0x33, 0xf1, 0xbd, 0xd0, 0xc3, 0x0d, + 0x2e, 0xb4, 0xde, 0xaf, 0x40, 0xb5, 0xeb, 0x84, 0x0e, 0xc6, 0x50, 0x3d, 0x26, 0xfe, 0xd8, 0x44, + 0x2d, 0xa3, 0x5d, 0xb5, 0xd9, 0x6f, 0xbc, 0x0a, 0xb5, 0x9e, 0x3b, 0x20, 0xcf, 0x4c, 0x83, 0x09, + 0xa3, 0x01, 0xde, 0x82, 0xe6, 0xee, 0x68, 0x1a, 0x84, 0xc4, 0xef, 0x75, 0xcd, 0x0a, 0xd3, 0x08, + 0x01, 0x6e, 0x43, 0xed, 0xc0, 0x1b, 0x90, 0xc0, 0xac, 0xb6, 0x2a, 0xed, 0xd9, 0x0e, 0xde, 0xe1, + 0xa1, 0x76, 0xa8, 0xb8, 0xe7, 0x3e, 0xf6, 0xec, 0xc8, 0x00, 0xff, 0x06, 0x9a, 0x34, 0xf2, 0x23, + 0x27, 0x20, 0x81, 0x59, 0x63, 0xd6, 0x6b, 0xc2, 0x9a, 0xab, 0x98, 0x87, 0x30, 0xa4, 0xf3, 0x3f, + 0x0c, 0x88, 0x1f, 0x98, 0x75, 0x75, 0x7e, 0x2a, 0x8e, 0xe6, 0x67, 0x06, 0x14, 0xe7, 0xbe, 0xf3, + 0x8c, 0x45, 0xed, 0x9a, 0x33, 0x11, 0xce, 0x44, 0x80, 0xdb, 0xb0, 0xb8, 0xef, 0x3c, 0xeb, 0x9f, + 0x3a, 0xfe, 0xe0, 0x9e, 0xef, 0x4d, 0x27, 0xbd, 0xae, 0xd9, 0x60, 0x36, 0xaa, 0x18, 0x6f, 0x03, + 0x70, 0x51, 0xaf, 0x6b, 0x36, 0x99, 0x91, 0x24, 0xc1, 0xbf, 0x8e, 0x78, 0x44, 0xac, 0x21, 0x97, + 0xb5, 0x30, 0xa2, 0x1e, 0xfb, 0x84, 0x7b, 0xcc, 0xe6, 0x7b, 0x24, 0x46, 0xd6, 0x1e, 0x34, 0xb8, + 0x18, 0x2f, 0x80, 0xd1, 0xeb, 0xc6, 0xdf, 0xc9, 0xe8, 0x75, 0xe9, 0x97, 0xdb, 0xf3, 0x82, 0x90, + 0x7d, 0xa4, 0xa6, 0xcd, 0x7e, 0x63, 0x13, 0x66, 0x8e, 0x77, 0x8f, 0x98, 0xb8, 0xd2, 0x42, 0xed, + 0xa6, 0xcd, 0x87, 0xd6, 0x37, 0x08, 0xe6, 0xe4, 0xdc, 0x52, 0xf7, 0x03, 0x67, 0x4c, 0xd8, 0x84, + 0x4d, 0x9b, 0xfd, 0xc6, 0xbf, 0x85, 0xb5, 0x2e, 0x79, 0xec, 0x4c, 0x47, 0xa1, 0x4d, 0x42, 0xe2, + 0x86, 0x43, 0xcf, 0x3d, 0xf2, 0x46, 0xc3, 0x93, 0xf3, 0x38, 0x48, 0x8e, 0x16, 0xdf, 0x87, 0xe5, + 0xb4, 0x68, 0x48, 0x02, 0xb3, 0xc2, 0x08, 0xde, 0x10, 0x04, 0x15, 0x2f, 0xc6, 0x35, 0xeb, 0x47, + 0x27, 0xdb, 0xf5, 0xdc, 0x70, 0xe8, 0x4e, 0xbd, 0x69, 0xf0, 0x60, 0x4a, 0xfc, 0x61, 0x52, 0x55, + 0xd2, 0x64, 0x69, 0x93, 0x78, 0xb2, 0x8c, 0x9f, 0xf5, 0x36, 0x82, 0x15, 0x25, 0x6e, 0x7f, 0x42, + 0x4e, 0x24, 0xf6, 0x28, 0x61, 0xbf, 0x09, 0x8d, 0xee, 0xd4, 0x77, 0xa8, 0xa5, 0x69, 0xb4, 0x50, + 0xbb, 0x62, 0x27, 0x63, 0xbc, 0x03, 0x58, 0x14, 0x47, 0x62, 0x55, 0x61, 0x56, 0x1a, 0x0d, 0x9d, + 0xcb, 0x26, 0x93, 0xd1, 0xf0, 0xc4, 0x39, 0x30, 0xab, 0x2d, 0xd4, 0x9e, 0xb7, 0x93, 0xb1, 0xf5, + 0x96, 0x91, 0xc1, 0x94, 0xfb, 0x45, 0xd2, 0x98, 0x8c, 0x4b, 0x61, 0x32, 0x2e, 0x85, 0xc9, 0x90, + 0x31, 0xe1, 0xdf, 0xc3, 0xac, 0xf0, 0xe0, 0xcb, 0xd2, 0x14, 0xe9, 0x96, 0x56, 0x06, 0xcd, 0xb4, + 0x6c, 0x8c, 0xff, 0x08, 0xf3, 0xfd, 0xe9, 0xa3, 0xe0, 0xc4, 0x1f, 0x4e, 0x68, 0x1c, 0xbe, 0x44, + 0x37, 0x25, 0x6f, 0x49, 0xcd, 0xfc, 0xd3, 0x0e, 0xd6, 0x97, 0x08, 0x16, 0xd2, 0x11, 0x32, 0xd5, + 0xbe, 0x05, 0xcd, 0x7e, 0xe8, 0xf8, 0xe1, 0xf1, 0x70, 0x4c, 0xe2, 0x4c, 0x08, 0x01, 0xad, 0xfb, + 0x3b, 0xee, 0x80, 0xe9, 0x22, 0xfe, 0x7c, 0x48, 0xfd, 0xba, 0x64, 0x44, 0x42, 0x32, 0xb8, 0x1d, + 0x32, 0xd6, 0x15, 0x5b, 0x08, 0xf0, 0x2f, 0xa0, 0xce, 0xe2, 0x72, 0xc6, 0x2b, 0x0a, 0x63, 0x06, + 0x36, 0x36, 0xc1, 0x2d, 0x98, 0x3d, 0xf6, 0xa7, 0xee, 0x89, 0x13, 0x4d, 0x56, 0x67, 0x1f, 0x5f, + 0x16, 0x59, 0x43, 0x68, 0x26, 0x6e, 0x19, 0x06, 0xdb, 0xd0, 0x38, 0x7c, 0xea, 0xd2, 0xcd, 0x32, + 0x30, 0x8d, 0x56, 0xa5, 0x5d, 0xfd, 0x93, 0x61, 0x22, 0x3b, 0x91, 0xe1, 0x5f, 0x42, 0x9d, 0xfd, + 0xe6, 0x2b, 0x67, 0x55, 0xc1, 0xc2, 0x94, 0x76, 0x6c, 0x63, 0xfd, 0x0d, 0x96, 0xd4, 0xac, 0x6a, + 0x0b, 0x08, 0x43, 0x75, 0xdf, 0x1b, 0x10, 0xbe, 0x4b, 0xd0, 0xdf, 0xd8, 0x82, 0xb9, 0x2e, 0x09, + 0xc2, 0xa1, 0xeb, 0x44, 0xdf, 0x8b, 0xc6, 0x6b, 0xda, 0x29, 0x99, 0x75, 0x13, 0x40, 0x44, 0xc5, + 0x6b, 0x50, 0x8f, 0x37, 0xd4, 0x88, 0x4f, 0x3c, 0xb2, 0xfe, 0x00, 0x2b, 0x9a, 0x85, 0xa8, 0x05, + 0xb2, 0x0a, 0x35, 0x66, 0x10, 0x23, 0x89, 0x06, 0xd6, 0x0b, 0x04, 0x0d, 0xbe, 0x81, 0xe7, 0xe1, + 0xdf, 0x73, 0x82, 0xd3, 0x64, 0x97, 0x73, 0x82, 0x53, 0x3a, 0xd5, 0xed, 0xc1, 0x78, 0x18, 0xd5, + 0x7a, 0xc3, 0x8e, 0x06, 0xf8, 0x77, 0x00, 0x47, 0xfe, 0xf0, 0x6c, 0x38, 0x22, 0x4f, 0x92, 0x0d, + 0x63, 0x3d, 0x7d, 0x4c, 0x24, 0x7a, 0x5b, 0x32, 0xb5, 0x7a, 0x30, 0x9f, 0x52, 0xb2, 0x45, 0x17, + 0x6f, 0x95, 0x31, 0x96, 0x64, 0x4c, 0xeb, 0x29, 0x31, 0x64, 0xa0, 0x6a, 0xb6, 0x10, 0x58, 0x5f, + 0xd7, 0x61, 0x66, 0xd7, 0x1b, 0x8f, 0x1d, 0x77, 0x80, 0x6f, 0x41, 0x35, 0x3c, 0x9f, 0x44, 0x33, + 0x2c, 0xc8, 0x47, 0x5c, 0x6c, 0xb0, 0x73, 0x7c, 0x3e, 0x21, 0x36, 0xb3, 0xb1, 0x5e, 0xd6, 0xa1, + 0x4a, 0x87, 0xf8, 0x1a, 0x2c, 0xef, 0xfa, 0xc4, 0x09, 0x09, 0x4d, 0x70, 0x6c, 0xb8, 0x84, 0xa8, + 0x38, 0x2a, 0x5a, 0x59, 0x6c, 0xe0, 0x0d, 0xb8, 0x16, 0x59, 0x73, 0x78, 0x5c, 0x55, 0xc1, 0xeb, + 0xb0, 0xd2, 0xf5, 0xbd, 0x89, 0xaa, 0xa8, 0xe2, 0x16, 0x6c, 0x45, 0x3e, 0xca, 0x16, 0xc4, 0x2d, + 0x6a, 0x78, 0x1b, 0x36, 0xa9, 0x6b, 0x8e, 0xbe, 0x8e, 0x6f, 0x42, 0xab, 0x4f, 0x42, 0xfd, 0x51, + 0xc0, 0xad, 0x66, 0x68, 0x9c, 0x87, 0x93, 0x41, 0x7e, 0x9c, 0x06, 0xbe, 0x0e, 0xeb, 0x11, 0x12, + 0xb1, 0xf4, 0xb9, 0xb2, 0x49, 0x95, 0x11, 0xe3, 0xac, 0x12, 0x04, 0x07, 0xa5, 0xf8, 0xb8, 0xc5, + 0x2c, 0xe7, 0x90, 0xa3, 0x9f, 0x13, 0x79, 0xa6, 0x5f, 0x9e, 0x8b, 0xe7, 0xf1, 0x0a, 0x2c, 0x52, + 0x37, 0x59, 0xb8, 0x40, 0x6d, 0x23, 0x26, 0xb2, 0x78, 0x91, 0x66, 0xb8, 0x4f, 0xc2, 0xe4, 0xdb, + 0x73, 0xc5, 0x12, 0xc6, 0xb0, 0x40, 0xf3, 0xe3, 0x84, 0x0e, 0x97, 0x2d, 0xe3, 0x2d, 0x30, 0xfb, + 0x24, 0x64, 0x85, 0x9a, 0xf1, 0xc0, 0x22, 0x82, 0xfc, 0x79, 0x57, 0xf0, 0x0d, 0xd8, 0x88, 0x13, + 0x24, 0xad, 0x74, 0xae, 0xbe, 0xc6, 0x52, 0xe4, 0x7b, 0x13, 0x9d, 0x72, 0x8d, 0x4e, 0x69, 0x93, + 0xb1, 0x77, 0x46, 0x8e, 0x88, 0x00, 0xbd, 0x2e, 0x2a, 0x86, 0xf7, 0x18, 0x5c, 0x65, 0xa6, 0x8b, + 0x49, 0x56, 0x6d, 0x50, 0x55, 0x84, 0x4f, 0x55, 0x6d, 0x52, 0x55, 0xf4, 0x9d, 0xd4, 0x09, 0xaf, + 0x0b, 0x95, 0xea, 0xb5, 0x85, 0xd7, 0x00, 0xf7, 0x49, 0xa8, 0xba, 0xdc, 0xc0, 0xab, 0xb0, 0xc4, + 0x28, 0xd1, 0x6f, 0xce, 0xa5, 0xdb, 0xb7, 0x1a, 0x8d, 0xc1, 0xd2, 0xc5, 0xc5, 0xc5, 0x85, 0x61, + 0xbd, 0x89, 0x34, 0xeb, 0x23, 0xe9, 0x84, 0x90, 0xd4, 0x09, 0x61, 0xa8, 0xda, 0x8e, 0x3b, 0x88, + 0x5b, 0x58, 0xf6, 0xbb, 0xb3, 0x07, 0x33, 0x27, 0xb1, 0xcb, 0x72, 0x66, 0x39, 0x9a, 0xa4, 0x85, + 0xda, 0xb3, 0x9d, 0xeb, 0x92, 0x42, 0x0d, 0x64, 0x73, 0x77, 0xeb, 0x0d, 0xa4, 0x59, 0x90, 0x99, + 0x1d, 0x7f, 0x15, 0x6a, 0x77, 0x3d, 0xff, 0x24, 0xda, 0x27, 0x1a, 0x76, 0x34, 0x28, 0x41, 0xf1, + 0x58, 0x45, 0x91, 0x09, 0x23, 0x50, 0x7c, 0x8e, 0x72, 0xd6, 0xbf, 0x76, 0x27, 0xbd, 0x07, 0x8b, + 0xd9, 0xae, 0x0e, 0x95, 0xb7, 0x68, 0xaa, 0x57, 0xe7, 0x2f, 0x85, 0x04, 0x9e, 0xb0, 0x39, 0x7f, + 0xa2, 0xa6, 0x51, 0x41, 0x28, 0x48, 0x4c, 0xb5, 0x1b, 0x95, 0x8e, 0x41, 0xe7, 0xcf, 0x85, 0x81, + 0x4f, 0x55, 0x32, 0x9a, 0x69, 0x45, 0xd8, 0xaf, 0x50, 0xf1, 0x3e, 0x58, 0x78, 0x08, 0x68, 0x53, + 0x69, 0xbc, 0x42, 0x2a, 0xfb, 0x85, 0x8c, 0x86, 0x8c, 0xd1, 0xcf, 0xd5, 0x54, 0xea, 0x01, 0x0b, + 0x6a, 0xef, 0xa2, 0xa2, 0x0d, 0xbc, 0x90, 0x18, 0xcf, 0xba, 0x21, 0x65, 0xfd, 0x41, 0x21, 0xc6, + 0xbf, 0x33, 0x8c, 0x37, 0xd3, 0x59, 0x2f, 0x43, 0xf8, 0x21, 0x2a, 0x3f, 0x42, 0xae, 0x8c, 0xf3, + 0xaf, 0x85, 0x38, 0xff, 0xc1, 0x70, 0xde, 0x92, 0x7a, 0xaa, 0x92, 0xf8, 0x02, 0xed, 0xb7, 0xa8, + 0xf8, 0x28, 0xbb, 0x2a, 0x52, 0xda, 0xad, 0x1e, 0x90, 0xa7, 0x4c, 0x1c, 0xdf, 0xd2, 0xe2, 0x61, + 0xaa, 0xdd, 0xaf, 0x2a, 0x57, 0x10, 0xb9, 0x7d, 0xaf, 0xa5, 0xaf, 0x14, 0x25, 0x75, 0x34, 0x52, + 0xeb, 0xa8, 0x88, 0x8d, 0xe0, 0xfd, 0x29, 0xca, 0x3d, 0xa0, 0x0b, 0x29, 0xaf, 0x41, 0x3d, 0x75, + 0x6b, 0x8c, 0x47, 0xb4, 0x75, 0xa2, 0x2d, 0x79, 0x10, 0x3a, 0xe3, 0x49, 0xdc, 0xa6, 0x0b, 0x41, + 0xe7, 0xa0, 0x90, 0xc2, 0x98, 0x51, 0xf8, 0xa9, 0xba, 0x14, 0x32, 0xc0, 0x04, 0xfa, 0xcf, 0x50, + 0x6e, 0x07, 0xf1, 0x4a, 0xe8, 0x2d, 0x98, 0x4b, 0xbd, 0x1a, 0x44, 0x2f, 0x20, 0x29, 0x59, 0x09, + 0x07, 0x57, 0xe5, 0x90, 0x03, 0x4f, 0x70, 0xf8, 0x04, 0x15, 0x37, 0x3a, 0x57, 0xae, 0xbc, 0xa4, + 0x09, 0xaf, 0x48, 0x4d, 0x78, 0x49, 0xf5, 0x78, 0xfa, 0x5d, 0x48, 0x8f, 0x28, 0xbb, 0x0b, 0xbd, + 0x1e, 0xe4, 0x25, 0xbb, 0xd0, 0x44, 0xb7, 0x0b, 0x95, 0x21, 0x7c, 0x89, 0x34, 0x4d, 0xe0, 0x0f, + 0xbb, 0x84, 0x94, 0x1c, 0xee, 0xff, 0xd4, 0xb7, 0x18, 0x52, 0x78, 0x81, 0x6e, 0x9c, 0x69, 0x45, + 0xb5, 0x67, 0xe2, 0xdd, 0xc2, 0x80, 0x3e, 0x0b, 0xb8, 0x91, 0xce, 0x8b, 0x36, 0x1c, 0xed, 0xac, + 0x32, 0x5d, 0xee, 0x65, 0x93, 0x51, 0x42, 0x3b, 0x50, 0x69, 0x67, 0x02, 0x09, 0x1c, 0x1f, 0x23, + 0x6d, 0x5b, 0x4d, 0xeb, 0x85, 0xda, 0xbb, 0x02, 0x4d, 0x32, 0x4e, 0xd5, 0x92, 0x51, 0x74, 0x5f, + 0xab, 0x28, 0xf7, 0xb5, 0x92, 0x8e, 0x22, 0x54, 0x3b, 0x0a, 0x0d, 0x30, 0x81, 0xfc, 0xb9, 0xda, + 0xf6, 0x63, 0x2b, 0x7a, 0x63, 0x65, 0x78, 0x67, 0x3b, 0x0b, 0xe9, 0x47, 0x4e, 0x9b, 0xe9, 0x3a, + 0x77, 0x0a, 0x11, 0x4c, 0x19, 0x02, 0x33, 0x7d, 0x6a, 0x89, 0x08, 0x22, 0xf8, 0x3b, 0x28, 0xff, + 0x82, 0x51, 0x98, 0xbb, 0xa4, 0x8c, 0x0d, 0xb9, 0x8c, 0x0f, 0x0b, 0x51, 0x9d, 0x31, 0x54, 0x56, + 0x0a, 0x95, 0x36, 0xb2, 0xc0, 0xf7, 0x02, 0x69, 0xae, 0x38, 0x97, 0x79, 0xd2, 0x2c, 0x29, 0xad, + 0xa7, 0xfa, 0xd2, 0xd2, 0xb6, 0xcb, 0xdf, 0xa1, 0x82, 0xfb, 0x54, 0xee, 0xeb, 0x5b, 0x5e, 0x61, + 0xb5, 0xb3, 0x3d, 0x60, 0xb4, 0xa9, 0xaa, 0xe2, 0xe4, 0x09, 0xa6, 0x5a, 0xf0, 0x04, 0x53, 0xcb, + 0x3e, 0xc1, 0x74, 0x8e, 0x0a, 0x99, 0x9f, 0x33, 0xe6, 0x3f, 0xcb, 0x9c, 0x88, 0x59, 0x6a, 0x22, + 0x03, 0x5f, 0xa0, 0xdc, 0x2b, 0xe3, 0x8f, 0xc7, 0xbf, 0xe4, 0x54, 0xfc, 0x57, 0xe6, 0x54, 0xd4, + 0x03, 0x4c, 0xd7, 0x52, 0xe6, 0x6e, 0x9b, 0xd4, 0x12, 0x12, 0xb5, 0x74, 0x7b, 0x30, 0xf0, 0x79, + 0x2d, 0xd1, 0xdf, 0x25, 0xb5, 0xf4, 0x5c, 0xad, 0xa5, 0x4c, 0x10, 0x81, 0xe1, 0x23, 0x94, 0x73, + 0x91, 0xa6, 0x39, 0xdb, 0x3b, 0x3e, 0x3e, 0x62, 0xb1, 0xe3, 0xc5, 0xc6, 0xc7, 0xf1, 0xf3, 0xbc, + 0x04, 0x8b, 0x0f, 0x93, 0xeb, 0x6a, 0x45, 0xba, 0xae, 0x16, 0xdf, 0xb3, 0xfe, 0xad, 0xbf, 0x67, + 0x29, 0x70, 0x52, 0xa7, 0x9d, 0xfe, 0x7e, 0xff, 0x6a, 0x88, 0x4b, 0xd0, 0xfd, 0x27, 0xff, 0x16, + 0xa8, 0x45, 0xf7, 0x1e, 0xca, 0x79, 0x62, 0xb8, 0xfa, 0xdf, 0x1e, 0x86, 0xf4, 0xb7, 0x47, 0x09, + 0xca, 0xff, 0xaa, 0x28, 0xb5, 0x10, 0xe4, 0xbb, 0xaa, 0xfe, 0xb1, 0x43, 0x05, 0x59, 0x12, 0xf6, + 0x7f, 0x6a, 0x58, 0xed, 0xa4, 0x22, 0xec, 0x59, 0xce, 0x43, 0x4a, 0x26, 0xec, 0x7e, 0x61, 0xd8, + 0x0b, 0xa4, 0x8f, 0x9b, 0x4b, 0xf7, 0x2e, 0xbd, 0x71, 0x04, 0x13, 0xcf, 0x0d, 0x08, 0x0d, 0x75, + 0x78, 0x9f, 0x85, 0x6a, 0xd8, 0xc6, 0xe1, 0x7d, 0x7a, 0x6e, 0xdc, 0xf1, 0x7d, 0xcf, 0x67, 0x6f, + 0x08, 0x4d, 0x3b, 0x1a, 0x88, 0x7f, 0x0e, 0x2b, 0x6c, 0x1d, 0x46, 0x03, 0xeb, 0x03, 0xa4, 0x7b, + 0xee, 0x79, 0x8d, 0x2b, 0xa5, 0xf8, 0x18, 0x7f, 0x11, 0xf1, 0xde, 0x4a, 0x9d, 0x57, 0xb9, 0xc9, + 0x1e, 0x65, 0x9f, 0xa0, 0x32, 0x79, 0x2e, 0xde, 0x47, 0xfe, 0x1f, 0xc5, 0xdb, 0x54, 0xb6, 0x34, + 0x69, 0xc2, 0x24, 0xda, 0xf7, 0x01, 0x00, 0x00, 0xff, 0xff, 0xaf, 0x93, 0x44, 0x75, 0xa7, 0x1d, + 0x00, 0x00, +} diff --git a/clients/backup/internal/meta.proto b/clients/backup/internal/meta.proto new file mode 100644 index 00000000..b5b19969 --- /dev/null +++ b/clients/backup/internal/meta.proto @@ -0,0 +1,397 @@ +// NOTE: This is a snapshot of the schema used to serialize V1 database info +// in the 2.0.x line of InfluxDB. The copy is here so we can support backing +// up from older DB versions, it's not intended to be kept up-to-date. + +package internal; + +//======================================================================== +// +// Metadata +// +//======================================================================== + +message Data { + required uint64 Term = 1; + required uint64 Index = 2; + required uint64 ClusterID = 3; + + repeated NodeInfo Nodes = 4; + repeated DatabaseInfo Databases = 5; + repeated UserInfo Users = 6; + + required uint64 MaxNodeID = 7; + required uint64 MaxShardGroupID = 8; + required uint64 MaxShardID = 9; + + // added for 0.10.0 + repeated NodeInfo DataNodes = 10; + repeated NodeInfo MetaNodes = 11; +} + +message NodeInfo { + required uint64 ID = 1; + required string Host = 2; + optional string TCPHost = 3; +} + +message DatabaseInfo { + required string Name = 1; + required string DefaultRetentionPolicy = 2; + repeated RetentionPolicyInfo RetentionPolicies = 3; + repeated ContinuousQueryInfo ContinuousQueries = 4; +} + +message RetentionPolicySpec { + optional string Name = 1; + optional int64 Duration = 2; + optional int64 ShardGroupDuration = 3; + optional uint32 ReplicaN = 4; +} + +message RetentionPolicyInfo { + required string Name = 1; + required int64 Duration = 2; + required int64 ShardGroupDuration = 3; + required uint32 ReplicaN = 4; + repeated ShardGroupInfo ShardGroups = 5; + repeated SubscriptionInfo Subscriptions = 6; +} + +message ShardGroupInfo { + required uint64 ID = 1; + required int64 StartTime = 2; + required int64 EndTime = 3; + required int64 DeletedAt = 4; + repeated ShardInfo Shards = 5; + optional int64 TruncatedAt = 6; +} + +message ShardInfo { + required uint64 ID = 1; + repeated uint64 OwnerIDs = 2 [deprecated=true]; + repeated ShardOwner Owners = 3; +} + +message SubscriptionInfo{ + required string Name = 1; + required string Mode = 2; + repeated string Destinations = 3; +} + +message ShardOwner { + required uint64 NodeID = 1; +} + +message ContinuousQueryInfo { + required string Name = 1; + required string Query = 2; +} + +message UserInfo { + required string Name = 1; + required string Hash = 2; + required bool Admin = 3; + repeated UserPrivilege Privileges = 4; +} + +message UserPrivilege { + required string Database = 1; + required int32 Privilege = 2; +} + + +//======================================================================== +// +// COMMANDS +// +//======================================================================== + +message Command { + extensions 100 to max; + + enum Type { + CreateNodeCommand = 1; + DeleteNodeCommand = 2; + CreateDatabaseCommand = 3; + DropDatabaseCommand = 4; + CreateRetentionPolicyCommand = 5; + DropRetentionPolicyCommand = 6; + SetDefaultRetentionPolicyCommand = 7; + UpdateRetentionPolicyCommand = 8; + CreateShardGroupCommand = 9; + DeleteShardGroupCommand = 10; + CreateContinuousQueryCommand = 11; + DropContinuousQueryCommand = 12; + CreateUserCommand = 13; + DropUserCommand = 14; + UpdateUserCommand = 15; + SetPrivilegeCommand = 16; + SetDataCommand = 17; + SetAdminPrivilegeCommand = 18; + UpdateNodeCommand = 19; + CreateSubscriptionCommand = 21; + DropSubscriptionCommand = 22; + RemovePeerCommand = 23; + CreateMetaNodeCommand = 24; + CreateDataNodeCommand = 25; + UpdateDataNodeCommand = 26; + DeleteMetaNodeCommand = 27; + DeleteDataNodeCommand = 28; + SetMetaNodeCommand = 29; + DropShardCommand = 30; + } + + required Type type = 1; +} + +// This isn't used in >= 0.10.0. Kept around for upgrade purposes. Instead +// look at CreateDataNodeCommand and CreateMetaNodeCommand +message CreateNodeCommand { + extend Command { + optional CreateNodeCommand command = 101; + } + required string Host = 1; + required uint64 Rand = 2; +} + +message DeleteNodeCommand { + extend Command { + optional DeleteNodeCommand command = 102; + } + required uint64 ID = 1; + required bool Force = 2; +} + +message CreateDatabaseCommand { + extend Command { + optional CreateDatabaseCommand command = 103; + } + required string Name = 1; + optional RetentionPolicyInfo RetentionPolicy = 2; +} + +message DropDatabaseCommand { + extend Command { + optional DropDatabaseCommand command = 104; + } + required string Name = 1; +} + +message CreateRetentionPolicyCommand { + extend Command { + optional CreateRetentionPolicyCommand command = 105; + } + required string Database = 1; + required RetentionPolicyInfo RetentionPolicy = 2; +} + +message DropRetentionPolicyCommand { + extend Command { + optional DropRetentionPolicyCommand command = 106; + } + required string Database = 1; + required string Name = 2; +} + +message SetDefaultRetentionPolicyCommand { + extend Command { + optional SetDefaultRetentionPolicyCommand command = 107; + } + required string Database = 1; + required string Name = 2; +} + +message UpdateRetentionPolicyCommand { + extend Command { + optional UpdateRetentionPolicyCommand command = 108; + } + required string Database = 1; + required string Name = 2; + optional string NewName = 3; + optional int64 Duration = 4; + optional uint32 ReplicaN = 5; +} + +message CreateShardGroupCommand { + extend Command { + optional CreateShardGroupCommand command = 109; + } + required string Database = 1; + required string Policy = 2; + required int64 Timestamp = 3; +} + +message DeleteShardGroupCommand { + extend Command { + optional DeleteShardGroupCommand command = 110; + } + required string Database = 1; + required string Policy = 2; + required uint64 ShardGroupID = 3; +} + +message CreateContinuousQueryCommand { + extend Command { + optional CreateContinuousQueryCommand command = 111; + } + required string Database = 1; + required string Name = 2; + required string Query = 3; +} + +message DropContinuousQueryCommand { + extend Command { + optional DropContinuousQueryCommand command = 112; + } + required string Database = 1; + required string Name = 2; +} + +message CreateUserCommand { + extend Command { + optional CreateUserCommand command = 113; + } + required string Name = 1; + required string Hash = 2; + required bool Admin = 3; +} + +message DropUserCommand { + extend Command { + optional DropUserCommand command = 114; + } + required string Name = 1; +} + +message UpdateUserCommand { + extend Command { + optional UpdateUserCommand command = 115; + } + required string Name = 1; + required string Hash = 2; +} + +message SetPrivilegeCommand { + extend Command { + optional SetPrivilegeCommand command = 116; + } + required string Username = 1; + required string Database = 2; + required int32 Privilege = 3; +} + +message SetDataCommand { + extend Command { + optional SetDataCommand command = 117; + } + required Data Data = 1; +} + +message SetAdminPrivilegeCommand { + extend Command { + optional SetAdminPrivilegeCommand command = 118; + } + required string Username = 1; + required bool Admin = 2; +} + +message UpdateNodeCommand { + extend Command { + optional UpdateNodeCommand command = 119; + } + required uint64 ID = 1; + required string Host = 2; +} + +message CreateSubscriptionCommand { + extend Command { + optional CreateSubscriptionCommand command = 121; + } + required string Name = 1; + required string Database = 2; + required string RetentionPolicy = 3; + required string Mode = 4; + repeated string Destinations = 5; + +} + +message DropSubscriptionCommand { + extend Command { + optional DropSubscriptionCommand command = 122; + } + required string Name = 1; + required string Database = 2; + required string RetentionPolicy = 3; +} + +message RemovePeerCommand { + extend Command { + optional RemovePeerCommand command = 123; + } + optional uint64 ID = 1; + required string Addr = 2; +} + +message CreateMetaNodeCommand { + extend Command { + optional CreateMetaNodeCommand command = 124; + } + required string HTTPAddr = 1; + required string TCPAddr = 2; + required uint64 Rand = 3; +} + +message CreateDataNodeCommand { + extend Command { + optional CreateDataNodeCommand command = 125; + } + required string HTTPAddr = 1; + required string TCPAddr = 2; +} + +message UpdateDataNodeCommand { + extend Command { + optional UpdateDataNodeCommand command = 126; + } + required uint64 ID = 1; + required string Host = 2; + required string TCPHost = 3; +} + +message DeleteMetaNodeCommand { + extend Command { + optional DeleteMetaNodeCommand command = 127; + } + required uint64 ID = 1; +} + +message DeleteDataNodeCommand { + extend Command { + optional DeleteDataNodeCommand command = 128; + } + required uint64 ID = 1; +} + +message Response { + required bool OK = 1; + optional string Error = 2; + optional uint64 Index = 3; +} + +// SetMetaNodeCommand is for the initial metanode in a cluster or +// if the single host restarts and its hostname changes, this will update it +message SetMetaNodeCommand { + extend Command { + optional SetMetaNodeCommand command = 129; + } + required string HTTPAddr = 1; + required string TCPAddr = 2; + required uint64 Rand = 3; +} + +message DropShardCommand { + extend Command { + optional DropShardCommand command = 130; + } + required uint64 ID = 1; +} diff --git a/clients/backup/testdata/test.bolt.gz b/clients/backup/testdata/test.bolt.gz new file mode 100644 index 00000000..45267719 Binary files /dev/null and b/clients/backup/testdata/test.bolt.gz differ diff --git a/go.mod b/go.mod index a5b701dc..412e6a88 100644 --- a/go.mod +++ b/go.mod @@ -10,6 +10,7 @@ require ( github.com/fatih/color v1.9.0 github.com/fujiwara/shapeio v1.0.0 github.com/gocarina/gocsv v0.0.0-20210408192840-02d7211d929d + github.com/gogo/protobuf v1.3.2 github.com/golang/mock v1.5.0 github.com/google/go-cmp v0.5.5 github.com/google/go-jsonnet v0.17.0 @@ -17,6 +18,7 @@ require ( github.com/olekukonko/tablewriter v0.0.5 github.com/stretchr/testify v1.7.0 github.com/urfave/cli v1.22.5 + go.etcd.io/bbolt v1.3.6 golang.org/x/text v0.3.3 golang.org/x/tools v0.1.0 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c diff --git a/go.sum b/go.sum index e23c5345..f694eff9 100644 --- a/go.sum +++ b/go.sum @@ -21,6 +21,8 @@ github.com/fujiwara/shapeio v1.0.0 h1:xG5D9oNqCSUUbryZ/jQV3cqe1v2suEjwPIcEg1gKM8 github.com/fujiwara/shapeio v1.0.0/go.mod h1:LmEmu6L/8jetyj1oewewFb7bZCNRwE7wLCUNzDLaLVA= github.com/gocarina/gocsv v0.0.0-20210408192840-02d7211d929d h1:r3mStZSyjKhEcgbJ5xtv7kT5PZw/tDiFBTMgQx2qsXE= github.com/gocarina/gocsv v0.0.0-20210408192840-02d7211d929d/go.mod h1:5YoVOkjYAQumqlV356Hj3xeYh4BdZuLE0/nRkf2NKkI= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/mock v1.5.0 h1:jlYHihg//f7RRwuPfptm04yp4s7O6Kw8EZiVYIGcH0g= github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= @@ -31,6 +33,7 @@ github.com/hinshun/vt10x v0.0.0-20180616224451-1954e6464174 h1:WlZsjVhE8Af9IcZDG github.com/hinshun/vt10x v0.0.0-20180616224451-1954e6464174/go.mod h1:DqJ97dSdRW1W22yXSB90986pcOyQ7r45iio1KN2ez1A= github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs= github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= @@ -68,18 +71,24 @@ github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5Cc github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/urfave/cli v1.22.5 h1:lNq9sAHXK2qfdI8W+GRItjCEkI+2oR4d+MEHy1CKXoU= github.com/urfave/cli v1.22.5/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU= +go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -87,6 +96,7 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190530182044-ad28b68e88f1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4 h1:myAQVi0cGEoqQVR5POX+8RR2mrocKqNN1hmeMqhX27k= golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -97,7 +107,9 @@ golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba h1:O8mE0/t419eoIwhTFpKVkHiT golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20201118003311-bd56c0adb394/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.0 h1:po9/4sTYwZU9lPhi1tOrb4hCv3qrhiQ77LZfGa2OjwY= golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= diff --git a/tools.go b/tools.go index 0015fac9..313b3b39 100644 --- a/tools.go +++ b/tools.go @@ -11,6 +11,7 @@ package influxcli import ( _ "github.com/daixiang0/gci" + _ "github.com/gogo/protobuf/protoc-gen-gogo" _ "github.com/golang/mock/mockgen" _ "golang.org/x/tools/cmd/goimports" _ "honnef.co/go/tools/cmd/staticcheck"