JakeHillion/storj
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add Version Information into KAD Network and SatelliteDB & Change Selection Process (#1648)

Browse Source 
* Initial Webserver Draft for Version Controlling

* Rename type to avoid confusion

* Move Function Calls into Version Package

* Fix Linting and Language Typos

* Fix Linting and Spelling Mistakes

* Include Copyright

* Include Copyright

* Adjust Version-Control Server to return list of Versions

* Linting

* Improve Request Handling and Readability

* Add Configuration File Option
Add Systemd Service file

* Add Logging to File

* Smaller Changes

* Add Semantic Versioning and refuses outdated Software from Startup (#1612)

* implements internal Semantic Version library

* adds version logging + reporting to process

* Advance SemVer struct for easier handling

* Add Accepted Version Store

* Fix Function

* Restructure

* Type Conversion

* Handle Version String properly

* Add Note about array index

* Set temporary Default Version

* Add Copyright

* Adding Version to Dashboard

* Adding Version Info Log

* Renaming and adding CheckerProcess

* Iteration Sync

* Iteration V2

* linting

* made LogAndReportVersion a go routine

* Refactor to Go Routine

* Add Context to Go Routine and allow Operation if Lookup to Control Server fails

* Handle Unmarshal properly

* Linting

* Relocate Version Checks

* Relocating Version Check and specified default Version for now

* Linting Error Prevention

* Refuse Startup on outdated Version

* Add Startup Check Function

* Straighten Logging

* Dont force Shutdown if --dev flag is set

* Create full Service/Peer Structure for ControlServer

* Linting

* Straighting Naming

* Finish VersionControl Service Layout

* Improve Error Handling

* Change Listening Address

* Move Checker Function

* Remove VersionControl Peer

* Linting

* Linting

* Create VersionClient Service

* Renaming

* Add Version Client to Peer Definitions

* Linting and Renaming

* Linting

* Remove Transport Checks for now

* Move to Client Side Flag

* Remove check

* Linting

* Transport Client Version Intro

* Adding Version Client to Transport Client

* Add missing parameter

* Adding Version Check, to set Allowed = true

* Set Default to true, testing

* Restructuring Code

* Uplink Changes

* Add more proper Defaults

* Renaming of Version struct

* Dont pass Service use Pointer

* Set Defaults for Versioning Checks

* Put HTTP Server in go routine

* Add Versioncontrol to Storj-Sim

* Testplanet Fixes

* Linting

* Add Error Handling and new Server Struct

* Move Lock slightly

* Reduce Race Potentials

* Remove unnecessary files

* Linting

* Add Proper Transport Handling

* small fixes

* add fence for allowed check

* Add Startup Version Check and Service Naming

* make errormessage private

* Add Comments about VersionedClient

* Linting

* Remove Checks that refuse outgoing connections

* Remove release cmd

* Add Release Script

* Linting

* Update to use correct Values

* Change Timestamp handling

* Adding Protobuf changes back in

* Adding SatelliteDB Changes and adding Storj Node Version to PB

* Add Migration Table

* Add Default Stats for Creation

* Move to BigInt

* Proper SQL Migration

* Ensure minimum Version is passed to the node selection

* Linting...

* Remove VersionedClient and adjust smaller changes from prior merge

* Linting

* Fix PB Message Handling and Query for Node Selection

* some future-proofing type changes

Change-Id: I3cb5018dcccdbc9739fe004d859065992720caaf

* fix a compiler error

Change-Id: If66bb92d8b98e31cd618ecec9c6448ab9b037fa5

* Comment on Constant for Overlay

* Remove NOT NULL and add epoch call as function

* add versions to bootstrap and satellites

Change-Id: I436944589ea5f21600cdd997742a84fe0b16e47b

* Change Update Migration

* Fix DB Migration

* Increase Timeout temporarily, to see whats going on

* Remove unnecessary const and vars
Cleanup Function calls from deprecated NodeVersion struct

* Updated Protopuf, removed depcreated Code from Inspector

* Implement NodeVersion into InfoResponse

* Regenerated locked.go

* Linting

* Fix Tests

* Remove unnecessary constant

* Update Function and Flag Description

* Remove Empty Stat Creation

* return properly with error

* Remove unnecessary struct

* simplify migration step

* Update Inspector to return Version Info

* Update local Endpoint Version Handling

* Reset Travis Timeout

* Add Default for CommitHash

* single quotes
This commit is contained in:
Stefan Benten 2019-04-10 08:04:24 +02:00 committed by GitHub
parent ffdb2e7728
commit bae4c820ee
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 1050 additions and 348 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bootstrap/peer.go
View File

@ -124,6 +124,11 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB, config Config, ver
config.ExternalAddress = peer.Addr()
}
pbVersion, err := versionInfo.Proto()
if err != nil {
return nil, errs.Combine(err, peer.Close())
}
self := pb.Node{
Id: peer.ID(),
Type: pb.NodeType_BOOTSTRAP,
@ -134,6 +139,7 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB, config Config, ver
Metadata: &pb.NodeMetadata{
Wallet: config.Operator.Wallet,
},
Version: pbVersion,
}
kdb, ndb := peer.DB.RoutingTable()

2
internal/testplanet/planet.go
View File

@ -745,7 +745,7 @@ func (planet *Planet) newVersionControlServer() (peer *versioncontrol.Peer, err
func (planet *Planet) NewVersionInfo() version.Info {
info := version.Info{
Timestamp: time.Now(),
CommitHash: "",
CommitHash: "testplanet",
Version: version.SemVer{
Major: 0,
Minor: 0,

19
internal/version/version.go
View File

@ -12,7 +12,10 @@ import (
"strings"
"time"
"github.com/golang/protobuf/ptypes"
monkit "gopkg.in/spacemonkeygo/monkit.v2"
"storj.io/storj/pkg/pb"
)
var (
@ -107,6 +110,22 @@ func (v Info) Marshal() (data []byte, err error) {
return
}
// Proto converts an Info struct to a pb.NodeVersion
// TODO: shouldn't we just use pb.NodeVersion everywhere? gogoproto will let
// us make it match Info.
func (v Info) Proto() (*pb.NodeVersion, error) {
pbts, err := ptypes.TimestampProto(v.Timestamp)
if err != nil {
return nil, err
}
return &pb.NodeVersion{
Version: v.Version.String(),
CommitHash: v.CommitHash,
Timestamp: pbts,
Release: v.Release,
}, nil
}
// containsVersion compares the allowed version array against the passed version
func containsVersion(all []SemVer, x SemVer) bool {
for _, n := range all {

2
pkg/discovery/service.go
View File

@ -159,7 +159,7 @@ func (discovery *Discovery) refresh(ctx context.Context) error {
continue
}
_, err = discovery.cache.UpdateOperator(ctx, ping.Id, *info.GetOperator())
_, err = discovery.cache.UpdateNodeInfo(ctx, ping.Id, info)
if err != nil {
discovery.log.Warn("could not update node operator", zap.String("ID", ping.GetAddress().String()))
}

6
pkg/kademlia/endpoint.go
View File

@ -93,5 +93,11 @@ func (endpoint *Endpoint) RequestInfo(ctx context.Context, req *pb.InfoRequest)
FreeBandwidth: self.GetRestrictions().GetFreeBandwidth(),
FreeDisk: self.GetRestrictions().GetFreeDisk(),
},
Version: &pb.NodeVersion{
Version: self.GetVersion().GetVersion(),
CommitHash: self.GetVersion().GetCommitHash(),
Timestamp: self.GetVersion().GetTimestamp(),
Release: self.GetVersion().GetRelease(),
},
}, nil
}

2
pkg/kademlia/inspector.go
View File

@ -129,10 +129,10 @@ func (srv *Inspector) NodeInfo(ctx context.Context, req *pb.NodeInfoRequest) (*p
if err != nil {
return &pb.NodeInfoResponse{}, err
}
return &pb.NodeInfoResponse{
Type: info.GetType(),
Operator: info.GetOperator(),
Capacity: info.GetCapacity(),
Version: info.GetVersion(),
}, nil
}

25
pkg/overlay/cache.go
View File

@ -17,8 +17,6 @@ import (
)
const (
// OverlayBucket is the string representing the bucket used for a bolt-backed overlay dht cache
OverlayBucket = "overlay"
// OnlineWindow is the maximum amount of time that can pass without seeing a node before that node is considered offline
OnlineWindow = 1 * time.Hour
)
@ -62,8 +60,8 @@ type DB interface {
FindInvalidNodes(ctx context.Context, nodeIDs storj.NodeIDList, maxStats *NodeStats) (invalid storj.NodeIDList, err error)
// UpdateStats all parts of single storagenode's stats.
UpdateStats(ctx context.Context, request *UpdateRequest) (stats *NodeStats, err error)
// UpdateOperator updates the email and wallet for a given node ID for satellite payments.
UpdateOperator(ctx context.Context, node storj.NodeID, updatedOperator pb.NodeOperator) (stats *NodeDossier, err error)
// UpdateNodeInfo updates node dossier with info requested from the node itself like node type, email, wallet, capacity, and version.
UpdateNodeInfo(ctx context.Context, node storj.NodeID, nodeInfo *pb.InfoResponse) (stats *NodeDossier, err error)
// UpdateUptime updates a single storagenode's uptime stats.
UpdateUptime(ctx context.Context, nodeID storj.NodeID, isUp bool) (stats *NodeStats, err error)
}
@ -77,6 +75,8 @@ type FindStorageNodesRequest struct {
FreeDisk int64
ExcludedNodes []storj.NodeID
MinimumVersion string // semver or empty
}
// NodeCriteria are the requirements for selecting nodes
@ -90,6 +90,8 @@ type NodeCriteria struct {
UptimeSuccessRatio float64
Excluded []storj.NodeID
MinimumVersion string // semver or empty
}
// NewNodeCriteria are the requirement for selecting new nodes
@ -100,6 +102,8 @@ type NewNodeCriteria struct {
AuditThreshold int64
Excluded []storj.NodeID
MinimumVersion string // semver or empty
}
// UpdateRequest is used to update a node status.
@ -116,6 +120,7 @@ type NodeDossier struct {
Operator pb.NodeOperator
Capacity pb.NodeCapacity
Reputation NodeStats
Version pb.NodeVersion
}
// Online checks if a node is online based on the collected statistics.
@ -219,7 +224,6 @@ func (cache *Cache) FindStorageNodesWithPreferences(ctx context.Context, req Fin
// TODO: add sanity limits to requested node count
// TODO: add sanity limits to excluded nodes
reputableNodeCount := req.MinimumRequiredNodes
if reputableNodeCount <= 0 {
reputableNodeCount = req.RequestedCount
@ -240,6 +244,8 @@ func (cache *Cache) FindStorageNodesWithPreferences(ctx context.Context, req Fin
UptimeSuccessRatio: preferences.UptimeRatio,
Excluded: req.ExcludedNodes,
MinimumVersion: preferences.MinimumVersion,
})
if err != nil {
return nil, err
@ -253,6 +259,8 @@ func (cache *Cache) FindStorageNodesWithPreferences(ctx context.Context, req Fin
AuditThreshold: preferences.NewNodeAuditThreshold,
Excluded: req.ExcludedNodes,
MinimumVersion: preferences.MinimumVersion,
})
if err != nil {
return nil, err
@ -292,7 +300,6 @@ func (cache *Cache) Put(ctx context.Context, nodeID storj.NodeID, value pb.Node)
if nodeID != value.Id {
return errors.New("invalid request")
}
return cache.db.Update(ctx, &value)
}
@ -314,10 +321,10 @@ func (cache *Cache) UpdateStats(ctx context.Context, request *UpdateRequest) (st
return cache.db.UpdateStats(ctx, request)
}
// UpdateOperator updates the email and wallet for a given node ID for satellite payments.
func (cache *Cache) UpdateOperator(ctx context.Context, node storj.NodeID, updatedOperator pb.NodeOperator) (stats *NodeDossier, err error) {
// UpdateNodeInfo updates node dossier with info requested from the node itself like node type, email, wallet, capacity, and version.
func (cache *Cache) UpdateNodeInfo(ctx context.Context, node storj.NodeID, nodeInfo *pb.InfoResponse) (stats *NodeDossier, err error) {
defer mon.Task()(&ctx)(&err)
return cache.db.UpdateOperator(ctx, node, updatedOperator)
return cache.db.UpdateNodeInfo(ctx, node, nodeInfo)
}
// UpdateUptime updates a single storagenode's uptime stats.

2
pkg/overlay/config.go
View File

@ -40,6 +40,8 @@ type NodeSelectionConfig struct {
NewNodeAuditThreshold int64 `help:"the number of audits a node must have to not be considered a New Node" default:"0"`
NewNodePercentage float64 `help:"the percentage of new nodes allowed per request" default:"0.05"` // TODO: fix, this is not percentage, it's ratio
MinimumVersion string `help:"the minimum node software version for node selection queries" default:""`
}
// ParseIDs converts the base58check encoded node ID strings from the config into node IDs

24
pkg/overlay/statdb_test.go
View File

@ -136,9 +136,11 @@ func testDatabase(ctx context.Context, t *testing.T, cache overlay.DB) {
err := cache.Update(ctx, &pb.Node{Id: nodeID})
require.NoError(t, err)
update, err := cache.UpdateOperator(ctx, nodeID, pb.NodeOperator{
Wallet: "0x1111111111111111111111111111111111111111",
Email: "abc123@gmail.com",
update, err := cache.UpdateNodeInfo(ctx, nodeID, &pb.InfoResponse{
Operator: &pb.NodeOperator{
Wallet: "0x1111111111111111111111111111111111111111",
Email: "abc123@gmail.com",
},
})
require.NoError(t, err)
@ -151,9 +153,11 @@ func testDatabase(ctx context.Context, t *testing.T, cache overlay.DB) {
assert.Equal(t, "0x1111111111111111111111111111111111111111", update.Operator.Wallet)
assert.Equal(t, "abc123@gmail.com", update.Operator.Email)
updateEmail, err := cache.UpdateOperator(ctx, nodeID, pb.NodeOperator{
Wallet: update.Operator.Wallet,
Email: "def456@gmail.com",
updateEmail, err := cache.UpdateNodeInfo(ctx, nodeID, &pb.InfoResponse{
Operator: &pb.NodeOperator{
Wallet: update.Operator.Wallet,
Email: "def456@gmail.com",
},
})
require.NoError(t, err)
@ -161,9 +165,11 @@ func testDatabase(ctx context.Context, t *testing.T, cache overlay.DB) {
assert.Equal(t, "0x1111111111111111111111111111111111111111", updateEmail.Operator.Wallet)
assert.Equal(t, "def456@gmail.com", updateEmail.Operator.Email)
updateWallet, err := cache.UpdateOperator(ctx, nodeID, pb.NodeOperator{
Wallet: "0x2222222222222222222222222222222222222222",
Email: updateEmail.Operator.Email,
updateWallet, err := cache.UpdateNodeInfo(ctx, nodeID, &pb.InfoResponse{
Operator: &pb.NodeOperator{
Wallet: "0x2222222222222222222222222222222222222222",
Email: updateEmail.Operator.Email,
},
})
require.NoError(t, err)

221
pkg/pb/inspector.pb.go
View File

@ -867,6 +867,7 @@ type NodeInfoResponse struct {
Type NodeType `protobuf:"varint,1,opt,name=type,proto3,enum=node.NodeType" json:"type,omitempty"`
Operator *NodeOperator `protobuf:"bytes,2,opt,name=operator,proto3" json:"operator,omitempty"`
Capacity *NodeCapacity `protobuf:"bytes,3,opt,name=capacity,proto3" json:"capacity,omitempty"`
Version *NodeVersion `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -917,6 +918,13 @@ func (m *NodeInfoResponse) GetCapacity() *NodeCapacity {
return nil
}
func (m *NodeInfoResponse) GetVersion() *NodeVersion {
if m != nil {
return m.Version
}
return nil
}
type FindNearRequest struct {
Id NodeID `protobuf:"bytes,1,opt,name=id,proto3,customtype=NodeID" json:"id"`
Start NodeID `protobuf:"bytes,2,opt,name=start,proto3,customtype=NodeID" json:"start"`
@ -1614,112 +1622,113 @@ func init() {
func init() { proto.RegisterFile("inspector.proto", fileDescriptor_a07d9034b2dd9d26) }
var fileDescriptor_a07d9034b2dd9d26 = []byte{
// 1671 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0xcd, 0x72, 0x1b, 0xc7,
0x11, 0xd6, 0xe2, 0x4f, 0x44, 0x03, 0xc4, 0xcf, 0x80, 0x92, 0x10, 0x48, 0x22, 0x98, 0xcd, 0x8f,
0x28, 0x29, 0x05, 0x29, 0x88, 0x72, 0x50, 0x54, 0x3a, 0x88, 0x64, 0x24, 0xa1, 0xc4, 0x48, 0xd4,
0x52, 0xb9, 0xa4, 0x54, 0x41, 0x0d, 0xb0, 0x43, 0x70, 0x43, 0x60, 0x67, 0xb5, 0x3b, 0x50, 0xc4,
0x17, 0x70, 0xd9, 0x2f, 0xe0, 0x2a, 0xfb, 0xea, 0x97, 0x70, 0xd9, 0x2f, 0xe0, 0x9b, 0xef, 0x3e,
0xe8, 0xe2, 0x2a, 0xfb, 0x19, 0x7c, 0x73, 0x4d, 0xcf, 0xec, 0x2f, 0x00, 0x93, 0xe5, 0x9f, 0x1b,
0xf6, 0xeb, 0x6f, 0x7a, 0xba, 0x7b, 0x66, 0x7a, 0xbe, 0x01, 0xd4, 0x1d, 0x37, 0xf0, 0xd8, 0x58,
0x70, 0xbf, 0xe7, 0xf9, 0x5c, 0x70, 0x52, 0x8e, 0x80, 0x0e, 0x4c, 0xf8, 0x84, 0x2b, 0xb8, 0x03,
0x2e, 0xb7, 0x99, 0xfe, 0x5d, 0xf7, 0xb8, 0xe3, 0x0a, 0xe6, 0xdb, 0x23, 0x0d, 0x6c, 0x4e, 0x38,
0x9f, 0x4c, 0xd9, 0x1d, 0xfc, 0x1a, 0xcd, 0x8f, 0xee, 0xd8, 0x73, 0x9f, 0x0a, 0x87, 0xbb, 0xda,
0xde, 0xcd, 0xda, 0x85, 0x33, 0x63, 0x81, 0xa0, 0x33, 0x4f, 0x11, 0xcc, 0xe7, 0xb0, 0xb9, 0xef,
0x04, 0x62, 0xe0, 0xfb, 0xcc, 0xa3, 0x3e, 0x1d, 0x4d, 0xd9, 0x21, 0x9b, 0xcc, 0x98, 0x2b, 0x02,
0x8b, 0xbd, 0x99, 0xb3, 0x40, 0x90, 0x0d, 0x28, 0x4e, 0x9d, 0x99, 0x23, 0xda, 0xc6, 0x96, 0xb1,
0x5d, 0xb4, 0xd4, 0x07, 0xb9, 0x0c, 0x25, 0x7e, 0x74, 0x14, 0x30, 0xd1, 0xce, 0x21, 0xac, 0xbf,
0xcc, 0xef, 0x0c, 0x20, 0x8b, 0xce, 0x08, 0x81, 0x82, 0x47, 0xc5, 0x31, 0xfa, 0xa8, 0x5a, 0xf8,
0x9b, 0xdc, 0x87, 0x5a, 0xa0, 0xcc, 0x43, 0x9b, 0x09, 0xea, 0x4c, 0xd1, 0x55, 0xa5, 0x4f, 0x7a,
0x71, 0x96, 0x07, 0xea, 0x97, 0xb5, 0xae, 0x99, 0x7b, 0x48, 0x24, 0x5d, 0xa8, 0x4c, 0x79, 0x20,
0x86, 0x9e, 0xc3, 0xc6, 0x2c, 0x68, 0xe7, 0x31, 0x04, 0x90, 0xd0, 0x01, 0x22, 0xa4, 0x07, 0xad,
0x29, 0x0d, 0xc4, 0x50, 0x06, 0xe2, 0xf8, 0x43, 0x2a, 0x04, 0x9b, 0x79, 0xa2, 0x5d, 0xd8, 0x32,
0xb6, 0xf3, 0x56, 0x53, 0x9a, 0x2c, 0xb4, 0x3c, 0x52, 0x06, 0x72, 0x17, 0x36, 0xd2, 0xd4, 0xe1,
0x98, 0xcf, 0x5d, 0xd1, 0x2e, 0xe2, 0x00, 0xe2, 0x27, 0xc9, 0xbb, 0xd2, 0x62, 0xbe, 0x86, 0xee,
0xca, 0xc2, 0x05, 0x1e, 0x77, 0x03, 0x46, 0xee, 0xc3, 0x9a, 0x0e, 0x3b, 0x68, 0x1b, 0x5b, 0xf9,
0xed, 0x4a, 0xff, 0x7a, 0x2f, 0x5e, 0xf4, 0xc5, 0x91, 0x56, 0x44, 0x37, 0xff, 0x01, 0xf5, 0x27,
0x4c, 0x1c, 0x0a, 0x1a, 0xaf, 0xc3, 0x0d, 0xb8, 0x28, 0x77, 0xc2, 0xd0, 0xb1, 0x55, 0x15, 0x77,
0x6a, 0x5f, 0xbd, 0xef, 0x5e, 0xf8, 0xe6, 0x7d, 0xb7, 0xf4, 0x9c, 0xdb, 0x6c, 0xb0, 0x67, 0x95,
0xa4, 0x79, 0x60, 0x9b, 0x9f, 0x1a, 0xd0, 0x88, 0x07, 0xeb, 0x58, 0xba, 0x50, 0xa1, 0x73, 0xdb,
0x09, 0xf3, 0x32, 0x30, 0x2f, 0x40, 0x08, 0xf3, 0x89, 0x09, 0xb8, 0x7f, 0x70, 0x29, 0x0c, 0x4d,
0xb0, 0x24, 0x42, 0x7e, 0x0f, 0xd5, 0xb9, 0x27, 0xb7, 0x8f, 0x76, 0x91, 0x47, 0x17, 0x15, 0x85,
0x29, 0x1f, 0x31, 0x45, 0x39, 0x29, 0xa0, 0x13, 0x4d, 0x41, 0x2f, 0xe6, 0xb7, 0x06, 0x90, 0x5d,
0x9f, 0x51, 0xc1, 0x7e, 0x56, 0x72, 0xd9, 0x3c, 0x72, 0x0b, 0x79, 0xf4, 0xa0, 0xa5, 0x08, 0xc1,
0x7c, 0x3c, 0x66, 0x41, 0x90, 0x8a, 0xb6, 0x89, 0xa6, 0x43, 0x65, 0xc9, 0xc6, 0xac, 0x88, 0x85,
0xc5, 0xb4, 0xee, 0xc2, 0x86, 0xa6, 0xa4, 0x7d, 0xea, 0xcd, 0xa1, 0x6c, 0x49, 0xa7, 0xe6, 0x25,
0x68, 0xa5, 0x92, 0x54, 0x8b, 0x60, 0xde, 0x02, 0x82, 0x76, 0x99, 0x53, 0xbc, 0x34, 0x1b, 0x50,
0x4c, 0x2e, 0x8a, 0xfa, 0x30, 0x5b, 0xd0, 0x4c, 0x72, 0xb1, 0x4c, 0x12, 0x7c, 0xc2, 0xc4, 0xce,
0x7c, 0x7c, 0xc2, 0xa2, 0xda, 0x99, 0x4f, 0x81, 0x24, 0xc1, 0xd8, 0xab, 0xe0, 0x82, 0x4e, 0x43,
0xaf, 0xf8, 0x41, 0xae, 0x41, 0xde, 0xb1, 0x83, 0x76, 0x6e, 0x2b, 0xbf, 0x5d, 0xdd, 0x81, 0x44,
0x7d, 0x25, 0x6c, 0xf6, 0x71, 0xe3, 0x28, 0x4f, 0xe1, 0xca, 0x6c, 0x42, 0x6e, 0xe5, 0xa2, 0xe4,
0x1c, 0xdb, 0xfc, 0x77, 0x22, 0xa4, 0x68, 0xf2, 0x33, 0x06, 0x91, 0x2d, 0x28, 0xca, 0xf5, 0x54,
0x81, 0x54, 0xfa, 0xd0, 0xc3, 0x1e, 0x27, 0x09, 0x96, 0x32, 0x98, 0xb7, 0xa0, 0xa4, 0x7c, 0x9e,
0x83, 0xdb, 0x03, 0x50, 0x5c, 0x79, 0x20, 0x63, 0xbe, 0xb1, 0x8a, 0xff, 0x0c, 0xea, 0x07, 0x8e,
0x3b, 0x41, 0xe8, 0x7c, 0x59, 0x92, 0x36, 0x5c, 0xa4, 0xb6, 0xed, 0xb3, 0x20, 0xc0, 0x2d, 0x57,
0xb6, 0xc2, 0x4f, 0xd3, 0x84, 0x46, 0xec, 0x4c, 0xa7, 0x5f, 0x83, 0x1c, 0x3f, 0x41, 0x6f, 0x6b,
0x56, 0x8e, 0x9f, 0x98, 0x0f, 0xa1, 0xb9, 0xcf, 0xf9, 0xc9, 0xdc, 0x4b, 0x4e, 0x59, 0x8b, 0xa6,
0x2c, 0x9f, 0x31, 0xc5, 0x6b, 0x20, 0xc9, 0xe1, 0x51, 0x8d, 0x0b, 0x32, 0x1d, 0xf4, 0x90, 0x4e,
0x13, 0x71, 0xf2, 0x67, 0x28, 0xcc, 0x98, 0xa0, 0x51, 0x53, 0x8d, 0xec, 0xff, 0x62, 0x82, 0xda,
0x54, 0x50, 0x0b, 0xed, 0xe6, 0x7f, 0xa1, 0x8e, 0x89, 0xba, 0x47, 0xfc, 0xbc, 0xd5, 0xb8, 0x9d,
0x0e, 0xb5, 0xd2, 0x6f, 0xc6, 0xde, 0x1f, 0x29, 0x43, 0x1c, 0xfd, 0xc7, 0x06, 0x34, 0xe2, 0x09,
0x74, 0xf0, 0x26, 0x14, 0xc4, 0xa9, 0xa7, 0x82, 0xaf, 0xf5, 0x6b, 0xf1, 0xf0, 0x57, 0xa7, 0x1e,
0xb3, 0xd0, 0x46, 0x7a, 0xb0, 0xc6, 0x3d, 0xe6, 0x53, 0xc1, 0xfd, 0xc5, 0x24, 0x5e, 0x68, 0x8b,
0x15, 0x71, 0x24, 0x7f, 0x4c, 0x3d, 0x3a, 0x76, 0xc4, 0x29, 0x1e, 0xf7, 0x14, 0x7f, 0x57, 0x5b,
0xac, 0x88, 0x63, 0xce, 0xa0, 0xfe, 0xd8, 0x71, 0xed, 0xe7, 0x8c, 0xfa, 0xe7, 0x4d, 0xfc, 0x8f,
0x50, 0x0c, 0x04, 0xf5, 0x55, 0xdf, 0x59, 0xa4, 0x28, 0x63, 0x7c, 0x63, 0xaa, 0xa6, 0xa3, 0x3e,
0xcc, 0x7b, 0xd0, 0x88, 0xa7, 0xd3, 0x65, 0x38, 0x7b, 0x6f, 0x13, 0x68, 0xec, 0xcd, 0x67, 0x5e,
0xaa, 0x0b, 0xfc, 0x1d, 0x9a, 0x09, 0x2c, 0xeb, 0x6a, 0xe5, 0xb6, 0xaf, 0x41, 0x35, 0xd9, 0x73,
0xcd, 0x1f, 0x0c, 0x68, 0x49, 0xe0, 0x70, 0x3e, 0x9b, 0x51, 0xff, 0x34, 0xf2, 0x74, 0x1d, 0x60,
0x1e, 0x30, 0x7b, 0x18, 0x78, 0x74, 0xcc, 0x74, 0xfb, 0x28, 0x4b, 0xe4, 0x50, 0x02, 0xe4, 0x06,
0xd4, 0xe9, 0x5b, 0xea, 0x4c, 0xe5, 0xc5, 0xa5, 0x39, 0xaa, 0x0b, 0xd7, 0x22, 0x58, 0x11, 0x65,
0x67, 0x95, 0x7e, 0x1c, 0x77, 0x82, 0x5b, 0x25, 0xbc, 0x30, 0x02, 0x66, 0x0f, 0x14, 0x24, 0xbb,
0x39, 0x52, 0x98, 0x62, 0xa8, 0xde, 0x8b, 0xb3, 0xff, 0x53, 0x11, 0xfe, 0x04, 0x35, 0x24, 0x8c,
0xa8, 0x6b, 0xff, 0xdf, 0xb1, 0xc5, 0xb1, 0x6e, 0xba, 0xeb, 0x12, 0xdd, 0x09, 0x41, 0x72, 0x07,
0x5a, 0x71, 0x4c, 0x31, 0xb7, 0xa4, 0x1a, 0x74, 0x64, 0x8a, 0x06, 0x60, 0x59, 0x69, 0x70, 0x3c,
0xe2, 0xd4, 0xb7, 0xc3, 0x7a, 0x7c, 0x9d, 0x87, 0x66, 0x02, 0xd4, 0xd5, 0x38, 0xf7, 0xcd, 0x74,
0x13, 0x1a, 0x48, 0x1c, 0x73, 0xd7, 0x65, 0x63, 0xa9, 0xc1, 0x02, 0x5d, 0x98, 0xba, 0xc4, 0x77,
0x63, 0x98, 0xdc, 0x86, 0xe6, 0x88, 0x73, 0x11, 0x08, 0x9f, 0x7a, 0xc3, 0xf0, 0x24, 0xe5, 0xf1,
0xd0, 0x37, 0x22, 0x83, 0x3e, 0x48, 0xd2, 0x2f, 0x6a, 0x20, 0x97, 0x4e, 0x23, 0x6e, 0x01, 0xb9,
0xf5, 0x10, 0x4f, 0x50, 0xd9, 0xbb, 0x0c, 0xb5, 0xa8, 0xa8, 0x21, 0x1e, 0x52, 0xef, 0xe1, 0x4e,
0x16, 0x01, 0xd6, 0xa8, 0xd2, 0xdf, 0x4c, 0x08, 0x93, 0x25, 0x7b, 0xc2, 0x52, 0x64, 0xf2, 0x57,
0x28, 0xa9, 0xdb, 0xae, 0x7d, 0x11, 0x87, 0xfd, 0xae, 0xa7, 0xf4, 0x65, 0x2f, 0xd4, 0x97, 0xbd,
0x3d, 0xad, 0x3f, 0x2d, 0x4d, 0x24, 0x0f, 0xa0, 0x82, 0x4a, 0xcc, 0x73, 0xdc, 0x09, 0xb3, 0xdb,
0x6b, 0x38, 0xae, 0xb3, 0x30, 0xee, 0x55, 0xa8, 0x4b, 0x2d, 0x90, 0xf4, 0x03, 0x64, 0x93, 0x87,
0x50, 0xc5, 0xc1, 0x6f, 0xe6, 0xcc, 0x77, 0x98, 0xdd, 0x2e, 0x9f, 0x39, 0x1a, 0x27, 0x7b, 0xa9,
0xe8, 0xe6, 0x27, 0x06, 0x6c, 0x68, 0x6d, 0xf5, 0x94, 0xd1, 0xa9, 0x38, 0x0e, 0xcf, 0xf9, 0x65,
0x28, 0x8d, 0xf0, 0xc6, 0xd0, 0x82, 0x54, 0x7f, 0xc9, 0xed, 0xc6, 0xdc, 0xb1, 0x7f, 0xea, 0x09,
0x66, 0x0f, 0x51, 0xb0, 0xe2, 0x41, 0xb7, 0xd6, 0x23, 0xf4, 0x40, 0x2a, 0xd7, 0x3f, 0x40, 0xa8,
0x47, 0x87, 0x8e, 0x6b, 0xb3, 0x77, 0x7a, 0x6b, 0x57, 0x35, 0x38, 0x90, 0x98, 0x3c, 0x46, 0x9e,
0xcf, 0xff, 0xc7, 0xc6, 0x42, 0xee, 0x9d, 0x02, 0xfa, 0x29, 0x6b, 0x64, 0x60, 0x9b, 0xfb, 0xb0,
0x9e, 0x0a, 0x4d, 0x1e, 0x17, 0xee, 0x4e, 0x1d, 0x97, 0x0d, 0xc3, 0x73, 0x2c, 0x45, 0x6d, 0x45,
0x61, 0x78, 0xd6, 0xe5, 0x15, 0xa1, 0xa7, 0xd0, 0x71, 0x85, 0x9f, 0xe6, 0x07, 0x06, 0x5c, 0xca,
0x64, 0xaa, 0xf7, 0xef, 0x5d, 0x28, 0x1d, 0x23, 0xa2, 0x2f, 0x8a, 0x76, 0x72, 0xa5, 0x53, 0x23,
0x34, 0x8f, 0x3c, 0x00, 0xf0, 0x99, 0x3d, 0x77, 0x6d, 0xea, 0x8e, 0x4f, 0x75, 0xe7, 0xbd, 0x9a,
0xd0, 0xe4, 0x56, 0x64, 0x3c, 0x1c, 0x1f, 0xb3, 0x19, 0xb3, 0x12, 0x74, 0xf3, 0x7b, 0x03, 0x5a,
0x2f, 0x46, 0x32, 0xc7, 0x74, 0xc5, 0x17, 0x2b, 0x6b, 0x2c, 0xab, 0x6c, 0xbc, 0x30, 0xb9, 0xd4,
0xc2, 0xa4, 0x8b, 0x99, 0xcf, 0x14, 0x53, 0x8a, 0x3e, 0x6c, 0xbd, 0x43, 0x7a, 0x24, 0x98, 0x3f,
0x0c, 0x8b, 0xa4, 0xe5, 0x3e, 0x9a, 0x1e, 0x49, 0x4b, 0xf8, 0x1c, 0xf9, 0x0b, 0x10, 0xe6, 0xda,
0xc3, 0x11, 0x3b, 0xe2, 0x3e, 0x8b, 0xe8, 0xaa, 0xb5, 0x34, 0x98, 0x6b, 0xef, 0xa0, 0x21, 0x64,
0x47, 0xfd, 0xbc, 0x94, 0x78, 0x01, 0x99, 0x1f, 0x19, 0xb0, 0x91, 0xce, 0x54, 0x57, 0xfc, 0xde,
0x82, 0xec, 0x5f, 0x5d, 0xf3, 0x88, 0xf9, 0x8b, 0xaa, 0xde, 0xff, 0x32, 0x0f, 0xd5, 0x67, 0xd4,
0x1e, 0x84, 0xb3, 0x90, 0x01, 0x40, 0xac, 0x1e, 0xc9, 0xb5, 0xc4, 0xfc, 0x0b, 0xa2, 0xb2, 0x73,
0x7d, 0x85, 0x55, 0xa7, 0xb3, 0x0b, 0x6b, 0xa1, 0xc0, 0x21, 0x9d, 0x04, 0x35, 0x23, 0xa1, 0x3a,
0x57, 0x97, 0xda, 0xb4, 0x93, 0x01, 0x40, 0x2c, 0x61, 0x52, 0xf1, 0x2c, 0x08, 0xa3, 0x54, 0x3c,
0x4b, 0x74, 0xcf, 0x2e, 0xac, 0x85, 0x72, 0x22, 0x15, 0x4f, 0x46, 0xc4, 0xa4, 0xe2, 0x59, 0xd0,
0x1f, 0xbb, 0xb0, 0x16, 0x5e, 0xc6, 0x29, 0x27, 0x19, 0x41, 0x90, 0x72, 0xb2, 0x70, 0x7b, 0x3f,
0x86, 0x72, 0x74, 0x0f, 0x93, 0x24, 0x33, 0x7b, 0x63, 0x77, 0xae, 0x2d, 0x37, 0x2a, 0x3f, 0xfd,
0xcf, 0x73, 0xd0, 0x78, 0xf1, 0x96, 0xf9, 0x53, 0x7a, 0xfa, 0x9b, 0xac, 0xe0, 0xaf, 0x14, 0xa7,
0x2c, 0x5a, 0xf8, 0xae, 0x4c, 0x15, 0x2d, 0xf3, 0x52, 0x4d, 0x15, 0x6d, 0xe1, 0x21, 0xba, 0x0f,
0x95, 0xc4, 0xd3, 0x88, 0xa4, 0x42, 0x5f, 0x78, 0x17, 0x76, 0x36, 0x57, 0x99, 0x75, 0xe9, 0x3e,
0x33, 0xa0, 0x85, 0x4f, 0xfe, 0x43, 0xc1, 0x7d, 0x16, 0x57, 0x6f, 0x07, 0x8a, 0xca, 0xff, 0x95,
0xcc, 0xc5, 0xb6, 0xd4, 0xf3, 0x92, 0x1b, 0xcf, 0xbc, 0x40, 0x9e, 0x42, 0x39, 0x92, 0x03, 0xe9,
0xb2, 0x65, 0x94, 0x43, 0xba, 0x6c, 0x59, 0x05, 0x61, 0x5e, 0xe8, 0x7f, 0x68, 0xc0, 0x46, 0xe2,
0xb9, 0x1f, 0x87, 0xe9, 0xc1, 0x95, 0x15, 0x7f, 0x22, 0x90, 0x9b, 0xc9, 0x53, 0xf0, 0x93, 0xff,
0xd0, 0x74, 0x6e, 0x9d, 0x87, 0xaa, 0x0b, 0xf6, 0x85, 0x01, 0x75, 0xd5, 0x7b, 0xe2, 0x28, 0x5e,
0x42, 0x35, 0xd9, 0xc8, 0x48, 0xb2, 0x34, 0x4b, 0x7a, 0x79, 0xa7, 0xbb, 0xd2, 0x1e, 0xd5, 0xee,
0x55, 0xf6, 0x76, 0xeb, 0xae, 0x6c, 0x81, 0xda, 0xe9, 0xd6, 0x6a, 0x42, 0xe8, 0x75, 0xa7, 0xf0,
0x9f, 0x9c, 0x37, 0x1a, 0x95, 0xf0, 0xda, 0xff, 0xdb, 0x8f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9c,
0x24, 0x48, 0x7d, 0x41, 0x13, 0x00, 0x00,
// 1688 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0x4b, 0x73, 0x1b, 0xc7,
0x11, 0xd6, 0xe2, 0x25, 0xa2, 0x01, 0xe2, 0x31, 0xa0, 0x24, 0x04, 0x92, 0x08, 0x66, 0xf3, 0x10,
0x25, 0xa5, 0x20, 0x05, 0x51, 0x0e, 0x8a, 0x4a, 0x07, 0x91, 0x8c, 0x24, 0x94, 0x18, 0x89, 0x5a,
0x2a, 0x39, 0xa4, 0x54, 0x41, 0x0d, 0xb0, 0x43, 0x70, 0x43, 0x60, 0x67, 0xb5, 0x3b, 0x50, 0xc4,
0x3f, 0x90, 0xb2, 0x7f, 0x82, 0x7d, 0xf5, 0x9f, 0x70, 0xd9, 0x47, 0x5f, 0x7c, 0xf3, 0xdd, 0x07,
0x5d, 0x5c, 0x65, 0xff, 0x06, 0xdf, 0x5c, 0xd3, 0x33, 0xfb, 0x04, 0x60, 0xb2, 0xfc, 0xb8, 0x61,
0xbf, 0xfe, 0xa6, 0xa7, 0xfb, 0x9b, 0x99, 0x9e, 0x1e, 0x40, 0xdd, 0x71, 0x03, 0x8f, 0x8d, 0x05,
0xf7, 0x7b, 0x9e, 0xcf, 0x05, 0x27, 0xe5, 0x08, 0xe8, 0xc0, 0x84, 0x4f, 0xb8, 0x82, 0x3b, 0xe0,
0x72, 0x9b, 0xe9, 0xdf, 0x75, 0x8f, 0x3b, 0xae, 0x60, 0xbe, 0x3d, 0xd2, 0xc0, 0xe6, 0x84, 0xf3,
0xc9, 0x94, 0xdd, 0xc1, 0xaf, 0xd1, 0xfc, 0xe8, 0x8e, 0x3d, 0xf7, 0xa9, 0x70, 0xb8, 0xab, 0xed,
0xdd, 0xac, 0x5d, 0x38, 0x33, 0x16, 0x08, 0x3a, 0xf3, 0x14, 0xc1, 0x7c, 0x0e, 0x9b, 0xfb, 0x4e,
0x20, 0x06, 0xbe, 0xcf, 0x3c, 0xea, 0xd3, 0xd1, 0x94, 0x1d, 0xb2, 0xc9, 0x8c, 0xb9, 0x22, 0xb0,
0xd8, 0x9b, 0x39, 0x0b, 0x04, 0xd9, 0x80, 0xe2, 0xd4, 0x99, 0x39, 0xa2, 0x6d, 0x6c, 0x19, 0xdb,
0x45, 0x4b, 0x7d, 0x90, 0xcb, 0x50, 0xe2, 0x47, 0x47, 0x01, 0x13, 0xed, 0x1c, 0xc2, 0xfa, 0xcb,
0xfc, 0xd6, 0x00, 0xb2, 0xe8, 0x8c, 0x10, 0x28, 0x78, 0x54, 0x1c, 0xa3, 0x8f, 0xaa, 0x85, 0xbf,
0xc9, 0x7d, 0xa8, 0x05, 0xca, 0x3c, 0xb4, 0x99, 0xa0, 0xce, 0x14, 0x5d, 0x55, 0xfa, 0xa4, 0x17,
0x67, 0x79, 0xa0, 0x7e, 0x59, 0xeb, 0x9a, 0xb9, 0x87, 0x44, 0xd2, 0x85, 0xca, 0x94, 0x07, 0x62,
0xe8, 0x39, 0x6c, 0xcc, 0x82, 0x76, 0x1e, 0x43, 0x00, 0x09, 0x1d, 0x20, 0x42, 0x7a, 0xd0, 0x9a,
0xd2, 0x40, 0x0c, 0x65, 0x20, 0x8e, 0x3f, 0xa4, 0x42, 0xb0, 0x99, 0x27, 0xda, 0x85, 0x2d, 0x63,
0x3b, 0x6f, 0x35, 0xa5, 0xc9, 0x42, 0xcb, 0x23, 0x65, 0x20, 0x77, 0x61, 0x23, 0x4d, 0x1d, 0x8e,
0xf9, 0xdc, 0x15, 0xed, 0x22, 0x0e, 0x20, 0x7e, 0x92, 0xbc, 0x2b, 0x2d, 0xe6, 0x6b, 0xe8, 0xae,
0x14, 0x2e, 0xf0, 0xb8, 0x1b, 0x30, 0x72, 0x1f, 0xd6, 0x74, 0xd8, 0x41, 0xdb, 0xd8, 0xca, 0x6f,
0x57, 0xfa, 0xd7, 0x7b, 0xf1, 0xa2, 0x2f, 0x8e, 0xb4, 0x22, 0xba, 0xf9, 0x37, 0xa8, 0x3f, 0x61,
0xe2, 0x50, 0xd0, 0x78, 0x1d, 0x6e, 0xc0, 0x45, 0xb9, 0x13, 0x86, 0x8e, 0xad, 0x54, 0xdc, 0xa9,
0x7d, 0xf9, 0xbe, 0x7b, 0xe1, 0xeb, 0xf7, 0xdd, 0xd2, 0x73, 0x6e, 0xb3, 0xc1, 0x9e, 0x55, 0x92,
0xe6, 0x81, 0x6d, 0x7e, 0x6c, 0x40, 0x23, 0x1e, 0xac, 0x63, 0xe9, 0x42, 0x85, 0xce, 0x6d, 0x27,
0xcc, 0xcb, 0xc0, 0xbc, 0x00, 0x21, 0xcc, 0x27, 0x26, 0xe0, 0xfe, 0xc1, 0xa5, 0x30, 0x34, 0xc1,
0x92, 0x08, 0xf9, 0x2d, 0x54, 0xe7, 0x9e, 0xdc, 0x3e, 0xda, 0x45, 0x1e, 0x5d, 0x54, 0x14, 0xa6,
0x7c, 0xc4, 0x14, 0xe5, 0xa4, 0x80, 0x4e, 0x34, 0x05, 0xbd, 0x98, 0xdf, 0x18, 0x40, 0x76, 0x7d,
0x46, 0x05, 0xfb, 0x49, 0xc9, 0x65, 0xf3, 0xc8, 0x2d, 0xe4, 0xd1, 0x83, 0x96, 0x22, 0x04, 0xf3,
0xf1, 0x98, 0x05, 0x41, 0x2a, 0xda, 0x26, 0x9a, 0x0e, 0x95, 0x25, 0x1b, 0xb3, 0x22, 0x16, 0x16,
0xd3, 0xba, 0x0b, 0x1b, 0x9a, 0x92, 0xf6, 0xa9, 0x37, 0x87, 0xb2, 0x25, 0x9d, 0x9a, 0x97, 0xa0,
0x95, 0x4a, 0x52, 0x2d, 0x82, 0x79, 0x0b, 0x08, 0xda, 0x65, 0x4e, 0xf1, 0xd2, 0x6c, 0x40, 0x31,
0xb9, 0x28, 0xea, 0xc3, 0x6c, 0x41, 0x33, 0xc9, 0x45, 0x99, 0x24, 0xf8, 0x84, 0x89, 0x9d, 0xf9,
0xf8, 0x84, 0x45, 0xda, 0x99, 0x4f, 0x81, 0x24, 0xc1, 0xd8, 0xab, 0xe0, 0x82, 0x4e, 0x43, 0xaf,
0xf8, 0x41, 0xae, 0x41, 0xde, 0xb1, 0x83, 0x76, 0x6e, 0x2b, 0xbf, 0x5d, 0xdd, 0x81, 0x84, 0xbe,
0x12, 0x36, 0xfb, 0xb8, 0x71, 0x94, 0xa7, 0x70, 0x65, 0x36, 0x21, 0xb7, 0x72, 0x51, 0x72, 0x8e,
0x6d, 0xfe, 0x33, 0x11, 0x52, 0x34, 0xf9, 0x19, 0x83, 0xc8, 0x16, 0x14, 0xe5, 0x7a, 0xaa, 0x40,
0x2a, 0x7d, 0xe8, 0x61, 0x8d, 0x93, 0x04, 0x4b, 0x19, 0xcc, 0x5b, 0x50, 0x52, 0x3e, 0xcf, 0xc1,
0xed, 0x01, 0x28, 0xae, 0x3c, 0x90, 0x31, 0xdf, 0x58, 0xc5, 0x7f, 0x06, 0xf5, 0x03, 0xc7, 0x9d,
0x20, 0x74, 0xbe, 0x2c, 0x49, 0x1b, 0x2e, 0x52, 0xdb, 0xf6, 0x59, 0x10, 0xe0, 0x96, 0x2b, 0x5b,
0xe1, 0xa7, 0x69, 0x42, 0x23, 0x76, 0xa6, 0xd3, 0xaf, 0x41, 0x8e, 0x9f, 0xa0, 0xb7, 0x35, 0x2b,
0xc7, 0x4f, 0xcc, 0x87, 0xd0, 0xdc, 0xe7, 0xfc, 0x64, 0xee, 0x25, 0xa7, 0xac, 0x45, 0x53, 0x96,
0xcf, 0x98, 0xe2, 0x35, 0x90, 0xe4, 0xf0, 0x48, 0xe3, 0x82, 0x4c, 0x07, 0x3d, 0xa4, 0xd3, 0x44,
0x9c, 0xfc, 0x11, 0x0a, 0x33, 0x26, 0x68, 0x54, 0x54, 0x23, 0xfb, 0x3f, 0x98, 0xa0, 0x36, 0x15,
0xd4, 0x42, 0xbb, 0xf9, 0x1f, 0xa8, 0x63, 0xa2, 0xee, 0x11, 0x3f, 0xaf, 0x1a, 0xb7, 0xd3, 0xa1,
0x56, 0xfa, 0xcd, 0xd8, 0xfb, 0x23, 0x65, 0x88, 0xa3, 0xff, 0xc2, 0x80, 0x46, 0x3c, 0x81, 0x0e,
0xde, 0x84, 0x82, 0x38, 0xf5, 0x54, 0xf0, 0xb5, 0x7e, 0x2d, 0x1e, 0xfe, 0xea, 0xd4, 0x63, 0x16,
0xda, 0x48, 0x0f, 0xd6, 0xb8, 0xc7, 0x7c, 0x2a, 0xb8, 0xbf, 0x98, 0xc4, 0x0b, 0x6d, 0xb1, 0x22,
0x8e, 0xe4, 0x8f, 0xa9, 0x47, 0xc7, 0x8e, 0x38, 0xc5, 0xe3, 0x9e, 0xe2, 0xef, 0x6a, 0x8b, 0x15,
0x71, 0x64, 0x16, 0x6f, 0x99, 0x1f, 0x38, 0xdc, 0xc5, 0x43, 0x9f, 0xca, 0xe2, 0x5f, 0xca, 0x60,
0x85, 0x0c, 0x73, 0x06, 0xf5, 0xc7, 0x8e, 0x6b, 0x3f, 0x67, 0xd4, 0x3f, 0xaf, 0x4a, 0xbf, 0x87,
0x62, 0x20, 0xa8, 0xaf, 0x8a, 0xd4, 0x22, 0x45, 0x19, 0xe3, 0xeb, 0x55, 0x55, 0x28, 0xf5, 0x61,
0xde, 0x83, 0x46, 0x3c, 0x9d, 0xd6, 0xec, 0xec, 0x83, 0x40, 0xa0, 0xb1, 0x37, 0x9f, 0x79, 0xa9,
0x92, 0xf1, 0x57, 0x68, 0x26, 0xb0, 0xac, 0xab, 0x95, 0x67, 0xa4, 0x06, 0xd5, 0x64, 0x81, 0x36,
0xbf, 0x37, 0xa0, 0x25, 0x81, 0xc3, 0xf9, 0x6c, 0x46, 0xfd, 0xd3, 0xc8, 0xd3, 0x75, 0x80, 0x79,
0xc0, 0xec, 0x61, 0xe0, 0xd1, 0x31, 0xd3, 0xb5, 0xa6, 0x2c, 0x91, 0x43, 0x09, 0x90, 0x1b, 0x50,
0xa7, 0x6f, 0xa9, 0x33, 0x95, 0xb7, 0x9c, 0xe6, 0xa8, 0x92, 0x5d, 0x8b, 0x60, 0x45, 0x94, 0x65,
0x58, 0xfa, 0x71, 0xdc, 0x09, 0xee, 0xab, 0xf0, 0x76, 0x09, 0x98, 0x3d, 0x50, 0x90, 0x2c, 0xfd,
0x48, 0x61, 0x8a, 0xa1, 0x0a, 0x35, 0xce, 0xfe, 0x77, 0x45, 0xf8, 0x03, 0xd4, 0x90, 0x30, 0xa2,
0xae, 0xfd, 0x3f, 0xc7, 0x16, 0xc7, 0xba, 0x42, 0xaf, 0x4b, 0x74, 0x27, 0x04, 0xc9, 0x1d, 0x68,
0xc5, 0x31, 0xc5, 0xdc, 0x92, 0xaa, 0xe6, 0x91, 0x29, 0x1a, 0x80, 0xb2, 0xd2, 0xe0, 0x78, 0xc4,
0xa9, 0x6f, 0x87, 0x7a, 0x7c, 0x95, 0x87, 0x66, 0x02, 0xd4, 0x6a, 0x9c, 0xfb, 0x1a, 0xbb, 0x09,
0x0d, 0x24, 0x8e, 0xb9, 0xeb, 0xb2, 0xb1, 0x6c, 0xd8, 0x02, 0x2d, 0x4c, 0x5d, 0xe2, 0xbb, 0x31,
0x4c, 0x6e, 0x43, 0x73, 0xc4, 0xb9, 0x08, 0x84, 0x4f, 0xbd, 0x61, 0x78, 0xec, 0xf2, 0x58, 0x21,
0x1a, 0x91, 0x41, 0x9f, 0x3a, 0xe9, 0x17, 0x1b, 0x26, 0x97, 0x4e, 0x23, 0x6e, 0x01, 0xb9, 0xf5,
0x10, 0x4f, 0x50, 0xd9, 0xbb, 0x0c, 0xb5, 0xa8, 0xa8, 0x21, 0x1e, 0x52, 0xef, 0xe1, 0x4e, 0x16,
0x01, 0x6a, 0x54, 0xe9, 0x6f, 0x26, 0xba, 0x98, 0x25, 0x7b, 0xc2, 0x52, 0x64, 0xf2, 0x67, 0x28,
0xa9, 0xab, 0xb1, 0x7d, 0x11, 0x87, 0xfd, 0xa6, 0xa7, 0x9a, 0xd1, 0x5e, 0xd8, 0x8c, 0xf6, 0xf6,
0x74, 0xb3, 0x6a, 0x69, 0x22, 0x79, 0x00, 0x15, 0x6c, 0xdb, 0x3c, 0xc7, 0x9d, 0x30, 0xbb, 0xbd,
0x86, 0xe3, 0x3a, 0x0b, 0xe3, 0x5e, 0x85, 0x4d, 0xac, 0x05, 0x92, 0x7e, 0x80, 0x6c, 0xf2, 0x10,
0xaa, 0x38, 0xf8, 0xcd, 0x9c, 0xf9, 0x0e, 0xb3, 0xdb, 0xe5, 0x33, 0x47, 0xe3, 0x64, 0x2f, 0x15,
0xdd, 0xfc, 0xc8, 0x80, 0x0d, 0xdd, 0x88, 0x3d, 0x65, 0x74, 0x2a, 0x8e, 0xc3, 0x73, 0x7e, 0x19,
0x4a, 0x23, 0xbc, 0x5e, 0x74, 0xf7, 0xaa, 0xbf, 0xe4, 0x76, 0x63, 0xee, 0xd8, 0x3f, 0xf5, 0x04,
0xb3, 0x87, 0xd8, 0xdd, 0xe2, 0x41, 0xb7, 0xd6, 0x23, 0xf4, 0x40, 0xb6, 0xb9, 0xbf, 0x83, 0xb0,
0x79, 0x1d, 0x3a, 0xae, 0xcd, 0xde, 0xe9, 0xad, 0x5d, 0xd5, 0xe0, 0x40, 0x62, 0xf2, 0x18, 0x79,
0x3e, 0xff, 0x2f, 0x1b, 0x0b, 0xb9, 0x77, 0x0a, 0xe8, 0xa7, 0xac, 0x91, 0x81, 0x6d, 0xee, 0xc3,
0x7a, 0x2a, 0x34, 0x79, 0x5c, 0xb8, 0x3b, 0x75, 0x5c, 0x36, 0x0c, 0xcf, 0xb1, 0xec, 0x80, 0x2b,
0x0a, 0xc3, 0xb3, 0x2e, 0xef, 0x13, 0x3d, 0x85, 0x8e, 0x2b, 0xfc, 0x34, 0xff, 0x6f, 0xc0, 0xa5,
0x4c, 0xa6, 0x7a, 0xff, 0xde, 0x85, 0xd2, 0x31, 0x22, 0xfa, 0x56, 0x69, 0x27, 0x57, 0x3a, 0x35,
0x42, 0xf3, 0xc8, 0x03, 0x00, 0x9f, 0xd9, 0x73, 0xd7, 0xa6, 0xee, 0xf8, 0x54, 0x97, 0xe9, 0xab,
0x89, 0x06, 0xde, 0x8a, 0x8c, 0x87, 0xe3, 0x63, 0x36, 0x63, 0x56, 0x82, 0x6e, 0x7e, 0x67, 0x40,
0xeb, 0xc5, 0x48, 0xe6, 0x98, 0x56, 0x7c, 0x51, 0x59, 0x63, 0x99, 0xb2, 0xf1, 0xc2, 0xe4, 0x52,
0x0b, 0x93, 0x16, 0x33, 0x9f, 0x11, 0x53, 0x76, 0x88, 0x58, 0x7a, 0x87, 0xf4, 0x48, 0x30, 0x7f,
0x18, 0x8a, 0xa4, 0xdf, 0x06, 0x68, 0x7a, 0x24, 0x2d, 0xe1, 0xdb, 0xe5, 0x4f, 0x40, 0x98, 0x6b,
0x0f, 0x47, 0xec, 0x88, 0xfb, 0x2c, 0xa2, 0xab, 0xd2, 0xd2, 0x60, 0xae, 0xbd, 0x83, 0x86, 0x90,
0x1d, 0xd5, 0xf3, 0x52, 0xe2, 0xb9, 0x64, 0x7e, 0x68, 0xc0, 0x46, 0x3a, 0x53, 0xad, 0xf8, 0xbd,
0x85, 0x37, 0xc2, 0x6a, 0xcd, 0x23, 0xe6, 0xcf, 0x52, 0xbd, 0xff, 0x79, 0x1e, 0xaa, 0xcf, 0xa8,
0x3d, 0x08, 0x67, 0x21, 0x03, 0x80, 0xb8, 0xd5, 0x24, 0xd7, 0x12, 0xf3, 0x2f, 0x74, 0xa0, 0x9d,
0xeb, 0x2b, 0xac, 0x3a, 0x9d, 0x5d, 0x58, 0x0b, 0xbb, 0x21, 0xd2, 0x49, 0x50, 0x33, 0xfd, 0x56,
0xe7, 0xea, 0x52, 0x9b, 0x76, 0x32, 0x00, 0x88, 0xfb, 0x9d, 0x54, 0x3c, 0x0b, 0x5d, 0x54, 0x2a,
0x9e, 0x25, 0x4d, 0xd2, 0x2e, 0xac, 0x85, 0xbd, 0x47, 0x2a, 0x9e, 0x4c, 0xc7, 0x93, 0x8a, 0x67,
0xa1, 0x59, 0xd9, 0x85, 0xb5, 0xf0, 0x32, 0x4e, 0x39, 0xc9, 0x34, 0x04, 0x29, 0x27, 0x0b, 0xb7,
0xf7, 0x63, 0x28, 0x47, 0xf7, 0x30, 0x49, 0x32, 0xb3, 0x37, 0x76, 0xe7, 0xda, 0x72, 0xa3, 0xf2,
0xd3, 0xff, 0x34, 0x07, 0x8d, 0x17, 0x6f, 0x99, 0x3f, 0xa5, 0xa7, 0xbf, 0xca, 0x0a, 0xfe, 0x42,
0x71, 0x4a, 0xd1, 0xc2, 0x47, 0x68, 0x4a, 0xb4, 0xcc, 0xb3, 0x36, 0x25, 0xda, 0xc2, 0xab, 0x75,
0x1f, 0x2a, 0x89, 0x77, 0x14, 0x49, 0x85, 0xbe, 0xf0, 0x88, 0xec, 0x6c, 0xae, 0x32, 0x6b, 0xe9,
0x3e, 0x31, 0xa0, 0x85, 0xff, 0x0f, 0x1c, 0x0a, 0xee, 0xb3, 0x58, 0xbd, 0x1d, 0x28, 0x2a, 0xff,
0x57, 0x32, 0x17, 0xdb, 0x52, 0xcf, 0x4b, 0x6e, 0x3c, 0xf3, 0x02, 0x79, 0x0a, 0xe5, 0xa8, 0x1d,
0x48, 0xcb, 0x96, 0xe9, 0x1c, 0xd2, 0xb2, 0x65, 0x3b, 0x08, 0xf3, 0x42, 0xff, 0x03, 0x03, 0x36,
0x12, 0xff, 0x0d, 0xc4, 0x61, 0x7a, 0x70, 0x65, 0xc5, 0x3f, 0x0e, 0xe4, 0x66, 0xf2, 0x14, 0xfc,
0xe8, 0xdf, 0x39, 0x9d, 0x5b, 0xe7, 0xa1, 0x6a, 0xc1, 0x3e, 0x33, 0xa0, 0xae, 0x6a, 0x4f, 0x1c,
0xc5, 0x4b, 0xa8, 0x26, 0x0b, 0x19, 0x49, 0x4a, 0xb3, 0xa4, 0x96, 0x77, 0xba, 0x2b, 0xed, 0x91,
0x76, 0xaf, 0xb2, 0xb7, 0x5b, 0x77, 0x65, 0x09, 0xd4, 0x4e, 0xb7, 0x56, 0x13, 0x42, 0xaf, 0x3b,
0x85, 0x7f, 0xe7, 0xbc, 0xd1, 0xa8, 0x84, 0xd7, 0xfe, 0x5f, 0x7e, 0x08, 0x00, 0x00, 0xff, 0xff,
0x9d, 0x4f, 0x03, 0xcd, 0x6e, 0x13, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

1
pkg/pb/inspector.proto
View File

@ -163,6 +163,7 @@ message NodeInfoResponse {
node.NodeType type = 1;
node.NodeOperator operator = 2;
node.NodeCapacity capacity = 3;
node.NodeVersion version = 4;
}
message FindNearRequest {

244
pkg/pb/node.pb.go
View File

@ -3,11 +3,13 @@
package pb
import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import timestamp "github.com/golang/protobuf/ptypes/timestamp"
import (
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
timestamp "github.com/golang/protobuf/ptypes/timestamp"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
@ -38,6 +40,7 @@ var NodeType_name = map[int32]string{
3: "UPLINK",
4: "BOOTSTRAP",
}
var NodeType_value = map[string]int32{
"INVALID": 0,
"SATELLITE": 1,
@ -49,8 +52,9 @@ var NodeType_value = map[string]int32{
func (x NodeType) String() string {
return proto.EnumName(NodeType_name, int32(x))
}
func (NodeType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_node_03c8840a1fd57936, []int{0}
return fileDescriptor_0c843d59d2d938e7, []int{0}
}
// NodeTransport is an enum of possible transports for the overlay network
@ -63,6 +67,7 @@ const (
var NodeTransport_name = map[int32]string{
0: "TCP_TLS_GRPC",
}
var NodeTransport_value = map[string]int32{
"TCP_TLS_GRPC": 0,
}
@ -70,8 +75,9 @@ var NodeTransport_value = map[string]int32{
func (x NodeTransport) String() string {
return proto.EnumName(NodeTransport_name, int32(x))
}
func (NodeTransport) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_node_03c8840a1fd57936, []int{1}
return fileDescriptor_0c843d59d2d938e7, []int{1}
}
// TODO move statdb.Update() stuff out of here
@ -90,6 +96,7 @@ type Node struct {
UpdateLatency bool `protobuf:"varint,10,opt,name=update_latency,json=updateLatency,proto3" json:"update_latency,omitempty"`
UpdateAuditSuccess bool `protobuf:"varint,11,opt,name=update_audit_success,json=updateAuditSuccess,proto3" json:"update_audit_success,omitempty"`
UpdateUptime bool `protobuf:"varint,12,opt,name=update_uptime,json=updateUptime,proto3" json:"update_uptime,omitempty"`
Version *NodeVersion `protobuf:"bytes,13,opt,name=version,proto3" json:"version,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -99,7 +106,7 @@ func (m *Node) Reset() { *m = Node{} }
func (m *Node) String() string { return proto.CompactTextString(m) }
func (*Node) ProtoMessage() {}
func (*Node) Descriptor() ([]byte, []int) {
return fileDescriptor_node_03c8840a1fd57936, []int{0}
return fileDescriptor_0c843d59d2d938e7, []int{0}
}
func (m *Node) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_Node.Unmarshal(m, b)
@ -107,8 +114,8 @@ func (m *Node) XXX_Unmarshal(b []byte) error {
func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_Node.Marshal(b, m, deterministic)
}
func (dst *Node) XXX_Merge(src proto.Message) {
xxx_messageInfo_Node.Merge(dst, src)
func (m *Node) XXX_Merge(src proto.Message) {
xxx_messageInfo_Node.Merge(m, src)
}
func (m *Node) XXX_Size() int {
return xxx_messageInfo_Node.Size(m)
@ -196,6 +203,13 @@ func (m *Node) GetUpdateUptime() bool {
return false
}
func (m *Node) GetVersion() *NodeVersion {
if m != nil {
return m.Version
}
return nil
}
// NodeAddress contains the information needed to communicate with a node on the network
type NodeAddress struct {
Transport NodeTransport `protobuf:"varint,1,opt,name=transport,proto3,enum=node.NodeTransport" json:"transport,omitempty"`
@ -209,7 +223,7 @@ func (m *NodeAddress) Reset() { *m = NodeAddress{} }
func (m *NodeAddress) String() string { return proto.CompactTextString(m) }
func (*NodeAddress) ProtoMessage() {}
func (*NodeAddress) Descriptor() ([]byte, []int) {
return fileDescriptor_node_03c8840a1fd57936, []int{1}
return fileDescriptor_0c843d59d2d938e7, []int{1}
}
func (m *NodeAddress) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NodeAddress.Unmarshal(m, b)
@ -217,8 +231,8 @@ func (m *NodeAddress) XXX_Unmarshal(b []byte) error {
func (m *NodeAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NodeAddress.Marshal(b, m, deterministic)
}
func (dst *NodeAddress) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeAddress.Merge(dst, src)
func (m *NodeAddress) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeAddress.Merge(m, src)
}
func (m *NodeAddress) XXX_Size() int {
return xxx_messageInfo_NodeAddress.Size(m)
@ -264,7 +278,7 @@ func (m *NodeStats) Reset() { *m = NodeStats{} }
func (m *NodeStats) String() string { return proto.CompactTextString(m) }
func (*NodeStats) ProtoMessage() {}
func (*NodeStats) Descriptor() ([]byte, []int) {
return fileDescriptor_node_03c8840a1fd57936, []int{2}
return fileDescriptor_0c843d59d2d938e7, []int{2}
}
func (m *NodeStats) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NodeStats.Unmarshal(m, b)
@ -272,8 +286,8 @@ func (m *NodeStats) XXX_Unmarshal(b []byte) error {
func (m *NodeStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NodeStats.Marshal(b, m, deterministic)
}
func (dst *NodeStats) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeStats.Merge(dst, src)
func (m *NodeStats) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeStats.Merge(m, src)
}
func (m *NodeStats) XXX_Size() int {
return xxx_messageInfo_NodeStats.Size(m)
@ -360,7 +374,7 @@ func (m *NodeOperator) Reset() { *m = NodeOperator{} }
func (m *NodeOperator) String() string { return proto.CompactTextString(m) }
func (*NodeOperator) ProtoMessage() {}
func (*NodeOperator) Descriptor() ([]byte, []int) {
return fileDescriptor_node_03c8840a1fd57936, []int{3}
return fileDescriptor_0c843d59d2d938e7, []int{3}
}
func (m *NodeOperator) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NodeOperator.Unmarshal(m, b)
@ -368,8 +382,8 @@ func (m *NodeOperator) XXX_Unmarshal(b []byte) error {
func (m *NodeOperator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NodeOperator.Marshal(b, m, deterministic)
}
func (dst *NodeOperator) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeOperator.Merge(dst, src)
func (m *NodeOperator) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeOperator.Merge(m, src)
}
func (m *NodeOperator) XXX_Size() int {
return xxx_messageInfo_NodeOperator.Size(m)
@ -407,7 +421,7 @@ func (m *NodeCapacity) Reset() { *m = NodeCapacity{} }
func (m *NodeCapacity) String() string { return proto.CompactTextString(m) }
func (*NodeCapacity) ProtoMessage() {}
func (*NodeCapacity) Descriptor() ([]byte, []int) {
return fileDescriptor_node_03c8840a1fd57936, []int{4}
return fileDescriptor_0c843d59d2d938e7, []int{4}
}
func (m *NodeCapacity) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NodeCapacity.Unmarshal(m, b)
@ -415,8 +429,8 @@ func (m *NodeCapacity) XXX_Unmarshal(b []byte) error {
func (m *NodeCapacity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NodeCapacity.Marshal(b, m, deterministic)
}
func (dst *NodeCapacity) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeCapacity.Merge(dst, src)
func (m *NodeCapacity) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeCapacity.Merge(m, src)
}
func (m *NodeCapacity) XXX_Size() int {
return xxx_messageInfo_NodeCapacity.Size(m)
@ -454,7 +468,7 @@ func (m *NodeMetadata) Reset() { *m = NodeMetadata{} }
func (m *NodeMetadata) String() string { return proto.CompactTextString(m) }
func (*NodeMetadata) ProtoMessage() {}
func (*NodeMetadata) Descriptor() ([]byte, []int) {
return fileDescriptor_node_03c8840a1fd57936, []int{5}
return fileDescriptor_0c843d59d2d938e7, []int{5}
}
func (m *NodeMetadata) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NodeMetadata.Unmarshal(m, b)
@ -462,8 +476,8 @@ func (m *NodeMetadata) XXX_Unmarshal(b []byte) error {
func (m *NodeMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NodeMetadata.Marshal(b, m, deterministic)
}
func (dst *NodeMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeMetadata.Merge(dst, src)
func (m *NodeMetadata) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeMetadata.Merge(m, src)
}
func (m *NodeMetadata) XXX_Size() int {
return xxx_messageInfo_NodeMetadata.Size(m)
@ -501,7 +515,7 @@ func (m *NodeRestrictions) Reset() { *m = NodeRestrictions{} }
func (m *NodeRestrictions) String() string { return proto.CompactTextString(m) }
func (*NodeRestrictions) ProtoMessage() {}
func (*NodeRestrictions) Descriptor() ([]byte, []int) {
return fileDescriptor_node_03c8840a1fd57936, []int{6}
return fileDescriptor_0c843d59d2d938e7, []int{6}
}
func (m *NodeRestrictions) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NodeRestrictions.Unmarshal(m, b)
@ -509,8 +523,8 @@ func (m *NodeRestrictions) XXX_Unmarshal(b []byte) error {
func (m *NodeRestrictions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NodeRestrictions.Marshal(b, m, deterministic)
}
func (dst *NodeRestrictions) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeRestrictions.Merge(dst, src)
func (m *NodeRestrictions) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeRestrictions.Merge(m, src)
}
func (m *NodeRestrictions) XXX_Size() int {
return xxx_messageInfo_NodeRestrictions.Size(m)
@ -535,7 +549,72 @@ func (m *NodeRestrictions) GetFreeDisk() int64 {
return 0
}
// NodeVersion contains
type NodeVersion struct {
Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
CommitHash string `protobuf:"bytes,2,opt,name=commit_hash,json=commitHash,proto3" json:"commit_hash,omitempty"`
Timestamp *timestamp.Timestamp `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
Release bool `protobuf:"varint,4,opt,name=release,proto3" json:"release,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *NodeVersion) Reset() { *m = NodeVersion{} }
func (m *NodeVersion) String() string { return proto.CompactTextString(m) }
func (*NodeVersion) ProtoMessage() {}
func (*NodeVersion) Descriptor() ([]byte, []int) {
return fileDescriptor_0c843d59d2d938e7, []int{7}
}
func (m *NodeVersion) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_NodeVersion.Unmarshal(m, b)
}
func (m *NodeVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_NodeVersion.Marshal(b, m, deterministic)
}
func (m *NodeVersion) XXX_Merge(src proto.Message) {
xxx_messageInfo_NodeVersion.Merge(m, src)
}
func (m *NodeVersion) XXX_Size() int {
return xxx_messageInfo_NodeVersion.Size(m)
}
func (m *NodeVersion) XXX_DiscardUnknown() {
xxx_messageInfo_NodeVersion.DiscardUnknown(m)
}
var xxx_messageInfo_NodeVersion proto.InternalMessageInfo
func (m *NodeVersion) GetVersion() string {
if m != nil {
return m.Version
}
return ""
}
func (m *NodeVersion) GetCommitHash() string {
if m != nil {
return m.CommitHash
}
return ""
}
func (m *NodeVersion) GetTimestamp() *timestamp.Timestamp {
if m != nil {
return m.Timestamp
}
return nil
}
func (m *NodeVersion) GetRelease() bool {
if m != nil {
return m.Release
}
return false
}
func init() {
proto.RegisterEnum("node.NodeType", NodeType_name, NodeType_value)
proto.RegisterEnum("node.NodeTransport", NodeTransport_name, NodeTransport_value)
proto.RegisterType((*Node)(nil), "node.Node")
proto.RegisterType((*NodeAddress)(nil), "node.NodeAddress")
proto.RegisterType((*NodeStats)(nil), "node.NodeStats")
@ -543,60 +622,63 @@ func init() {
proto.RegisterType((*NodeCapacity)(nil), "node.NodeCapacity")
proto.RegisterType((*NodeMetadata)(nil), "node.NodeMetadata")
proto.RegisterType((*NodeRestrictions)(nil), "node.NodeRestrictions")
proto.RegisterEnum("node.NodeType", NodeType_name, NodeType_value)
proto.RegisterEnum("node.NodeTransport", NodeTransport_name, NodeTransport_value)
proto.RegisterType((*NodeVersion)(nil), "node.NodeVersion")
}
func init() { proto.RegisterFile("node.proto", fileDescriptor_node_03c8840a1fd57936) }
func init() { proto.RegisterFile("node.proto", fileDescriptor_0c843d59d2d938e7) }
var fileDescriptor_node_03c8840a1fd57936 = []byte{
// 753 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x4f, 0x6f, 0xda, 0x48,
0x18, 0xc6, 0x03, 0x76, 0x00, 0xbf, 0xfc, 0x59, 0x67, 0x12, 0x45, 0x56, 0x56, 0xbb, 0x10, 0xa2,
0xd5, 0xa2, 0xac, 0x44, 0xb2, 0xd9, 0x53, 0x56, 0xbd, 0x00, 0x49, 0x23, 0x54, 0x17, 0xd0, 0xe0,
0xe4, 0x90, 0x8b, 0x35, 0xe0, 0x09, 0x1d, 0xc5, 0x60, 0xcb, 0x1e, 0x2b, 0xe2, 0x1b, 0xf6, 0x33,
0xf4, 0x90, 0x73, 0x6f, 0xfd, 0x0a, 0xd5, 0xcc, 0xd8, 0x01, 0xa7, 0xaa, 0xd4, 0x4a, 0xbd, 0x31,
0xcf, 0xf3, 0x9b, 0xf7, 0x1d, 0xe6, 0x79, 0xc7, 0x00, 0xab, 0xc0, 0xa3, 0xdd, 0x30, 0x0a, 0x78,
0x80, 0x74, 0xf1, 0xfb, 0x08, 0x16, 0xc1, 0x22, 0x50, 0xca, 0x51, 0x73, 0x11, 0x04, 0x0b, 0x9f,
0x9e, 0xc9, 0xd5, 0x2c, 0x79, 0x38, 0xe3, 0x6c, 0x49, 0x63, 0x4e, 0x96, 0xa1, 0x02, 0xda, 0x5f,
0x34, 0xd0, 0x47, 0x81, 0x47, 0xd1, 0x9f, 0x50, 0x64, 0x9e, 0x55, 0x68, 0x15, 0x3a, 0xb5, 0x7e,
0xe3, 0xe3, 0x73, 0x73, 0xe7, 0xd3, 0x73, 0xb3, 0x24, 0x9c, 0xe1, 0x15, 0x2e, 0x32, 0x0f, 0xfd,
0x03, 0x65, 0xe2, 0x79, 0x11, 0x8d, 0x63, 0xab, 0xd8, 0x2a, 0x74, 0xaa, 0x17, 0x7b, 0x5d, 0xd9,
0x59, 0x20, 0x3d, 0x65, 0xe0, 0x8c, 0x40, 0x6d, 0xd0, 0xf9, 0x3a, 0xa4, 0x96, 0xd6, 0x2a, 0x74,
0x1a, 0x17, 0x8d, 0x0d, 0xe9, 0xac, 0x43, 0x8a, 0xa5, 0x87, 0xfe, 0x87, 0x5a, 0x44, 0x63, 0x1e,
0xb1, 0x39, 0x67, 0xc1, 0x2a, 0xb6, 0x74, 0x59, 0xf5, 0x70, 0xc3, 0xe2, 0x2d, 0x17, 0xe7, 0x58,
0x74, 0x06, 0x10, 0xd1, 0x30, 0xe1, 0x44, 0x2c, 0xad, 0x5d, 0xb9, 0xf3, 0xb7, 0xcd, 0xce, 0x29,
0x27, 0x3c, 0xc6, 0x5b, 0x08, 0xea, 0x42, 0x65, 0x49, 0x39, 0xf1, 0x08, 0x27, 0x56, 0x49, 0xe2,
0x68, 0x83, 0xbf, 0x4f, 0x1d, 0xfc, 0xc2, 0xa0, 0x63, 0xa8, 0xf9, 0x84, 0xd3, 0xd5, 0x7c, 0xed,
0xfa, 0x2c, 0xe6, 0x56, 0xb9, 0xa5, 0x75, 0x34, 0x5c, 0x4d, 0x35, 0x9b, 0xc5, 0x1c, 0x9d, 0x40,
0x9d, 0x24, 0x1e, 0xe3, 0x6e, 0x9c, 0xcc, 0xe7, 0xe2, 0x5a, 0x2a, 0xad, 0x42, 0xa7, 0x82, 0x6b,
0x52, 0x9c, 0x2a, 0x0d, 0xed, 0xc3, 0x2e, 0x8b, 0xdd, 0x24, 0xb4, 0x0c, 0x69, 0xea, 0x2c, 0xbe,
0x0d, 0xd1, 0x5f, 0xd0, 0x48, 0x42, 0x8f, 0x70, 0xea, 0xa6, 0xf5, 0x2c, 0x90, 0x6e, 0x5d, 0xa9,
0xb6, 0x12, 0xd1, 0x39, 0x1c, 0xa4, 0x58, 0xbe, 0x4f, 0x55, 0xc2, 0x48, 0x79, 0xbd, 0xed, 0x6e,
0x27, 0x90, 0x96, 0x70, 0x93, 0x50, 0x04, 0x6d, 0xd5, 0xd4, 0x91, 0x94, 0x78, 0x2b, 0xb5, 0xf6,
0x3d, 0x54, 0xb7, 0x32, 0x43, 0xff, 0x82, 0xc1, 0x23, 0xb2, 0x8a, 0xc3, 0x20, 0xe2, 0x32, 0xfe,
0xc6, 0xc5, 0xfe, 0x56, 0x5e, 0x99, 0x85, 0x37, 0x14, 0xb2, 0xf2, 0xa3, 0x60, 0xbc, 0xe4, 0xde,
0xfe, 0xac, 0x81, 0xf1, 0x12, 0x00, 0xfa, 0x1b, 0xca, 0xa2, 0x90, 0xfb, 0xdd, 0xb9, 0x2a, 0x09,
0x7b, 0xe8, 0xa1, 0x3f, 0x00, 0xb2, 0xdb, 0xbe, 0x3c, 0x97, 0x35, 0x35, 0x6c, 0xa4, 0xca, 0xe5,
0x39, 0xea, 0xc2, 0x7e, 0xee, 0x06, 0xdc, 0x48, 0x84, 0x2a, 0x87, 0xab, 0x80, 0xf7, 0xb6, 0xef,
0x1b, 0x0b, 0x43, 0x84, 0xa7, 0xfe, 0x7f, 0x0a, 0xea, 0x12, 0xac, 0x2a, 0x4d, 0x21, 0x4d, 0xa8,
0xaa, 0x92, 0xf3, 0x20, 0x59, 0x71, 0x39, 0x41, 0x1a, 0x06, 0x29, 0x0d, 0x84, 0xf2, 0x6d, 0x4f,
0x05, 0x96, 0x24, 0x98, 0xeb, 0xa9, 0xf8, 0x4d, 0x4f, 0x05, 0x96, 0x25, 0x98, 0xf6, 0x54, 0x88,
0xcc, 0x53, 0x22, 0xf9, 0x9a, 0x15, 0x89, 0x22, 0xe5, 0xe5, 0x8a, 0xda, 0x70, 0xe0, 0x93, 0x58,
0x1c, 0x72, 0xc5, 0xc9, 0x7c, 0x33, 0x01, 0x86, 0x9c, 0xe0, 0xa3, 0xae, 0x7a, 0xdc, 0xdd, 0xec,
0x71, 0x77, 0x9d, 0xec, 0x71, 0x63, 0x24, 0xf6, 0x0d, 0xd4, 0xb6, 0x6c, 0x3a, 0x5e, 0x57, 0x7b,
0x20, 0xcc, 0x4f, 0x22, 0x2a, 0x87, 0xef, 0xc7, 0xab, 0xbd, 0x55, 0xbb, 0xda, 0x6f, 0xa0, 0x26,
0x52, 0x1c, 0x87, 0x34, 0x22, 0x3c, 0x88, 0xd0, 0x01, 0xec, 0xd2, 0x25, 0x61, 0xbe, 0x8c, 0xda,
0xc0, 0x6a, 0x81, 0x0e, 0xa1, 0xf4, 0x44, 0x7c, 0x9f, 0xf2, 0x74, 0x52, 0xd2, 0x55, 0x1b, 0xab,
0xdd, 0x03, 0x12, 0x92, 0x39, 0xe3, 0x6b, 0xf1, 0x24, 0x1e, 0x22, 0x4a, 0xdd, 0x19, 0x59, 0x79,
0x4f, 0xcc, 0xe3, 0x1f, 0x64, 0x19, 0x0d, 0xd7, 0x85, 0xda, 0xcf, 0x44, 0xf4, 0x3b, 0x18, 0x12,
0xf3, 0x58, 0xfc, 0x98, 0xce, 0x49, 0x45, 0x08, 0x57, 0x2c, 0x7e, 0xcc, 0x4e, 0x94, 0xbd, 0xe6,
0x9f, 0x3c, 0xd1, 0x1d, 0x98, 0xaf, 0x3f, 0x3a, 0xbf, 0xe2, 0x54, 0xa7, 0x23, 0xa8, 0x64, 0x1f,
0x3e, 0x54, 0x85, 0xf2, 0x70, 0x74, 0xd7, 0xb3, 0x87, 0x57, 0xe6, 0x0e, 0xaa, 0x83, 0x31, 0xed,
0x39, 0xd7, 0xb6, 0x3d, 0x74, 0xae, 0xcd, 0x82, 0xf0, 0xa6, 0xce, 0x18, 0xf7, 0x6e, 0xae, 0xcd,
0x22, 0x02, 0x28, 0xdd, 0x4e, 0xec, 0xe1, 0xe8, 0x9d, 0xa9, 0x09, 0xae, 0x3f, 0x1e, 0x3b, 0x53,
0x07, 0xf7, 0x26, 0xa6, 0x7e, 0x7a, 0x0c, 0xf5, 0xdc, 0xc3, 0x44, 0x26, 0xd4, 0x9c, 0xc1, 0xc4,
0x75, 0xec, 0xa9, 0x7b, 0x83, 0x27, 0x03, 0x73, 0xa7, 0xaf, 0xdf, 0x17, 0xc3, 0xd9, 0xac, 0x24,
0x83, 0xfc, 0xef, 0x6b, 0x00, 0x00, 0x00, 0xff, 0xff, 0x3e, 0x7b, 0x8b, 0xf5, 0x21, 0x06, 0x00,
0x00,
var fileDescriptor_0c843d59d2d938e7 = []byte{
// 828 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xcf, 0x6e, 0xdb, 0x46,
0x10, 0xc6, 0x4d, 0x91, 0x96, 0xc4, 0xd1, 0x9f, 0x32, 0x6b, 0x23, 0x20, 0x5c, 0xb4, 0x56, 0x14,
0x14, 0x15, 0x52, 0x40, 0x76, 0xdd, 0x4b, 0x53, 0xf4, 0x22, 0xcb, 0x6e, 0x2a, 0x94, 0xb5, 0x8d,
0x15, 0xed, 0x43, 0x2e, 0xc4, 0x8a, 0x5c, 0x4b, 0x8b, 0x50, 0x22, 0xc1, 0x5d, 0x36, 0xd0, 0xbb,
0xe4, 0x81, 0xfa, 0x0c, 0x3d, 0xe4, 0xdc, 0xc7, 0x28, 0x76, 0x97, 0x14, 0x45, 0x17, 0x2d, 0x5a,
0x20, 0x37, 0xee, 0x37, 0xbf, 0x9d, 0x19, 0x70, 0xbe, 0x1d, 0x80, 0x4d, 0x12, 0xd1, 0x71, 0x9a,
0x25, 0x22, 0x41, 0x96, 0xfc, 0x3e, 0x81, 0x65, 0xb2, 0x4c, 0xb4, 0x72, 0x72, 0xba, 0x4c, 0x92,
0x65, 0x4c, 0xcf, 0xd4, 0x69, 0x91, 0x3f, 0x9e, 0x09, 0xb6, 0xa6, 0x5c, 0x90, 0x75, 0xaa, 0x81,
0xe1, 0x07, 0x0b, 0xac, 0x9b, 0x24, 0xa2, 0xe8, 0x4b, 0x68, 0xb0, 0xc8, 0x35, 0x06, 0xc6, 0xa8,
0x7b, 0xd9, 0xff, 0xfd, 0xe3, 0xe9, 0xc1, 0x1f, 0x1f, 0x4f, 0x9b, 0x32, 0x32, 0xbb, 0xc2, 0x0d,
0x16, 0xa1, 0x6f, 0xa0, 0x45, 0xa2, 0x28, 0xa3, 0x9c, 0xbb, 0x8d, 0x81, 0x31, 0xea, 0x5c, 0x3c,
0x1b, 0xab, 0xca, 0x12, 0x99, 0xe8, 0x00, 0x2e, 0x09, 0x34, 0x04, 0x4b, 0x6c, 0x53, 0xea, 0x9a,
0x03, 0x63, 0xd4, 0xbf, 0xe8, 0x57, 0xa4, 0xbf, 0x4d, 0x29, 0x56, 0x31, 0xf4, 0x03, 0x74, 0x33,
0xca, 0x45, 0xc6, 0x42, 0xc1, 0x92, 0x0d, 0x77, 0x2d, 0x95, 0xf5, 0x79, 0xc5, 0xe2, 0xbd, 0x28,
0xae, 0xb1, 0xe8, 0x0c, 0x20, 0xa3, 0x69, 0x2e, 0x88, 0x3c, 0xba, 0x87, 0xea, 0xe6, 0x67, 0xd5,
0xcd, 0xb9, 0x20, 0x82, 0xe3, 0x3d, 0x04, 0x8d, 0xa1, 0xbd, 0xa6, 0x82, 0x44, 0x44, 0x10, 0xb7,
0xa9, 0x70, 0x54, 0xe1, 0xbf, 0x16, 0x11, 0xbc, 0x63, 0xd0, 0x0b, 0xe8, 0xc6, 0x44, 0xd0, 0x4d,
0xb8, 0x0d, 0x62, 0xc6, 0x85, 0xdb, 0x1a, 0x98, 0x23, 0x13, 0x77, 0x0a, 0xcd, 0x63, 0x5c, 0xa0,
0x97, 0xd0, 0x23, 0x79, 0xc4, 0x44, 0xc0, 0xf3, 0x30, 0x94, 0xbf, 0xa5, 0x3d, 0x30, 0x46, 0x6d,
0xdc, 0x55, 0xe2, 0x5c, 0x6b, 0xe8, 0x08, 0x0e, 0x19, 0x0f, 0xf2, 0xd4, 0xb5, 0x55, 0xd0, 0x62,
0xfc, 0x3e, 0x45, 0x5f, 0x41, 0x3f, 0x4f, 0x23, 0x22, 0x68, 0x50, 0xe4, 0x73, 0x41, 0x45, 0x7b,
0x5a, 0xf5, 0xb4, 0x88, 0xce, 0xe1, 0xb8, 0xc0, 0xea, 0x75, 0x3a, 0x0a, 0x46, 0x3a, 0x36, 0xd9,
0xaf, 0xf6, 0x12, 0x8a, 0x14, 0x41, 0x9e, 0xca, 0x41, 0xbb, 0x5d, 0xdd, 0x92, 0x16, 0xef, 0x95,
0x26, 0x07, 0xf9, 0x1b, 0xcd, 0xb8, 0xfc, 0x71, 0xbd, 0xa7, 0x83, 0x7c, 0xd0, 0x01, 0x5c, 0x12,
0xc3, 0xb7, 0xd0, 0xd9, 0x1b, 0x30, 0xfa, 0x16, 0x6c, 0x91, 0x91, 0x0d, 0x4f, 0x93, 0x4c, 0x28,
0xaf, 0xf4, 0x2f, 0x8e, 0xf6, 0x86, 0x5b, 0x86, 0x70, 0x45, 0x21, 0xb7, 0xee, 0x1b, 0x7b, 0x67,
0x92, 0xe1, 0x9f, 0x26, 0xd8, 0xbb, 0x69, 0xa1, 0xaf, 0xa1, 0x25, 0x13, 0x05, 0xff, 0x68, 0xc2,
0xa6, 0x0c, 0xcf, 0x22, 0xf4, 0x05, 0x40, 0x39, 0x9a, 0xd7, 0xe7, 0x2a, 0xa7, 0x89, 0xed, 0x42,
0x79, 0x7d, 0x8e, 0xc6, 0x70, 0x54, 0xfb, 0x5d, 0x41, 0x26, 0x1d, 0xa0, 0x9c, 0x68, 0xe0, 0x67,
0xfb, 0xc3, 0xc1, 0x32, 0x20, 0x27, 0xad, 0x7f, 0x56, 0x01, 0x5a, 0x0a, 0xec, 0x68, 0x4d, 0x23,
0xa7, 0xd0, 0xd1, 0x29, 0xc3, 0x24, 0xdf, 0x08, 0x65, 0x37, 0x13, 0x83, 0x92, 0xa6, 0x52, 0xf9,
0x7b, 0x4d, 0x0d, 0x36, 0x15, 0x58, 0xab, 0xa9, 0xf9, 0xaa, 0xa6, 0x06, 0x5b, 0x0a, 0x2c, 0x6a,
0x6a, 0x44, 0x0d, 0x5f, 0x21, 0xf5, 0x9c, 0x6d, 0x85, 0x22, 0x1d, 0xab, 0x25, 0xf5, 0xe0, 0x38,
0x26, 0x5c, 0x36, 0xb9, 0x11, 0x24, 0xac, 0xec, 0x62, 0xab, 0x21, 0x9f, 0x8c, 0xf5, 0x26, 0x18,
0x97, 0x9b, 0x60, 0xec, 0x97, 0x9b, 0x00, 0x23, 0x79, 0x6f, 0xaa, 0xaf, 0x95, 0x56, 0x7a, 0x9a,
0xed, 0x91, 0xb0, 0x38, 0xcf, 0xa8, 0x72, 0xea, 0x7f, 0xcf, 0xf6, 0x93, 0xbe, 0x35, 0xfc, 0x11,
0xba, 0x72, 0x8a, 0xb7, 0x29, 0xcd, 0x88, 0x48, 0x32, 0x74, 0x0c, 0x87, 0x74, 0x4d, 0x58, 0xac,
0x46, 0x6d, 0x63, 0x7d, 0x40, 0xcf, 0xa1, 0xf9, 0x9e, 0xc4, 0x31, 0x15, 0x85, 0x53, 0x8a, 0xd3,
0x10, 0xeb, 0xdb, 0x53, 0x92, 0x92, 0x90, 0x89, 0xad, 0x7c, 0x3f, 0x8f, 0x19, 0xa5, 0xc1, 0x82,
0x6c, 0xa2, 0xf7, 0x2c, 0x12, 0x2b, 0x95, 0xc6, 0xc4, 0x3d, 0xa9, 0x5e, 0x96, 0x22, 0xfa, 0x1c,
0x6c, 0x85, 0x45, 0x8c, 0xbf, 0x2b, 0x7c, 0xd2, 0x96, 0xc2, 0x15, 0xe3, 0xef, 0xca, 0x8e, 0xca,
0xa7, 0xff, 0x3f, 0x3b, 0x7a, 0x00, 0xe7, 0xe9, 0x86, 0xfa, 0x24, 0x5d, 0x7d, 0x30, 0xf4, 0x7b,
0x2b, 0xde, 0xa1, 0x7c, 0x3c, 0xe5, 0x5b, 0xd5, 0x7d, 0x95, 0x47, 0xe9, 0xc9, 0x30, 0x59, 0xaf,
0x99, 0x08, 0x56, 0x84, 0xaf, 0x8a, 0xf6, 0x40, 0x4b, 0x3f, 0x13, 0xbe, 0x42, 0xdf, 0x83, 0xbd,
0xdb, 0xf5, 0xca, 0xfd, 0xff, 0x3e, 0xb5, 0x0a, 0x96, 0x45, 0x33, 0x1a, 0x53, 0xc2, 0xa9, 0x7a,
0x0c, 0x6d, 0x5c, 0x1e, 0x5f, 0xdd, 0x40, 0xbb, 0x5c, 0xe2, 0xa8, 0x03, 0xad, 0xd9, 0xcd, 0xc3,
0xc4, 0x9b, 0x5d, 0x39, 0x07, 0xa8, 0x07, 0xf6, 0x7c, 0xe2, 0x5f, 0x7b, 0xde, 0xcc, 0xbf, 0x76,
0x0c, 0x19, 0x9b, 0xfb, 0xb7, 0x78, 0xf2, 0xe6, 0xda, 0x69, 0x20, 0x80, 0xe6, 0xfd, 0x9d, 0x37,
0xbb, 0xf9, 0xc5, 0x31, 0x25, 0x77, 0x79, 0x7b, 0xeb, 0xcf, 0x7d, 0x3c, 0xb9, 0x73, 0xac, 0x57,
0x2f, 0xa0, 0x57, 0xdb, 0x1b, 0xc8, 0x81, 0xae, 0x3f, 0xbd, 0x0b, 0x7c, 0x6f, 0x1e, 0xbc, 0xc1,
0x77, 0x53, 0xe7, 0xe0, 0xd2, 0x7a, 0xdb, 0x48, 0x17, 0x8b, 0xa6, 0xea, 0xf8, 0xbb, 0xbf, 0x02,
0x00, 0x00, 0xff, 0xff, 0x8f, 0x51, 0xee, 0x90, 0xed, 0x06, 0x00, 0x00,
}

9
pkg/pb/node.proto
View File

@ -25,6 +25,7 @@ message Node {
bool update_latency = 10;
bool update_audit_success = 11;
bool update_uptime = 12;
NodeVersion version = 13;
}
// NodeType is an enum of possible node types
@ -83,3 +84,11 @@ message NodeRestrictions {
int64 free_bandwidth = 1;
int64 free_disk = 2;
}
// NodeVersion contains
message NodeVersion {
string version = 1; // must be semver formatted
string commit_hash = 2;
google.protobuf.Timestamp timestamp = 3;
bool release = 4;
}

71
pkg/pb/overlay.pb.go
View File

@ -285,6 +285,7 @@ type InfoResponse struct {
Type NodeType `protobuf:"varint,2,opt,name=type,proto3,enum=node.NodeType" json:"type,omitempty"`
Operator *NodeOperator `protobuf:"bytes,3,opt,name=operator,proto3" json:"operator,omitempty"`
Capacity *NodeCapacity `protobuf:"bytes,4,opt,name=capacity,proto3" json:"capacity,omitempty"`
Version *NodeVersion `protobuf:"bytes,5,opt,name=version,proto3" json:"version,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -335,6 +336,13 @@ func (m *InfoResponse) GetCapacity() *NodeCapacity {
return nil
}
func (m *InfoResponse) GetVersion() *NodeVersion {
if m != nil {
return m.Version
}
return nil
}
type Restriction struct {
Operator Restriction_Operator `protobuf:"varint,1,opt,name=operator,proto3,enum=overlay.Restriction_Operator" json:"operator,omitempty"`
Operand Restriction_Operand `protobuf:"varint,2,opt,name=operand,proto3,enum=overlay.Restriction_Operand" json:"operand,omitempty"`
@ -404,37 +412,38 @@ func init() {
func init() { proto.RegisterFile("overlay.proto", fileDescriptor_61fc82527fbe24ad) }
var fileDescriptor_61fc82527fbe24ad = []byte{
// 473 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xcf, 0x8e, 0xd3, 0x3e,
0x10, 0xc7, 0xd7, 0x49, 0xda, 0xe6, 0x37, 0xfd, 0xa3, 0xc8, 0xda, 0xfd, 0x29, 0x8a, 0x40, 0xaa,
0x72, 0x40, 0x3d, 0xa0, 0x1c, 0xba, 0x68, 0x25, 0xb8, 0xb1, 0x34, 0x2c, 0x15, 0xab, 0x85, 0x35,
0x91, 0x90, 0xe0, 0x80, 0xd2, 0xc6, 0x44, 0x11, 0xc5, 0x0e, 0x8e, 0xbb, 0x52, 0xde, 0x80, 0x33,
0x4f, 0xc2, 0xf3, 0x71, 0x42, 0x76, 0x9c, 0x34, 0x14, 0x90, 0x38, 0xd9, 0x33, 0xdf, 0xcf, 0x64,
0x66, 0x3c, 0x13, 0x98, 0xf2, 0x3b, 0x2a, 0x76, 0x69, 0x1d, 0x95, 0x82, 0x4b, 0x8e, 0x47, 0xc6,
0x0c, 0x20, 0xe7, 0x39, 0x6f, 0x9c, 0x01, 0x30, 0x9e, 0xd1, 0xe6, 0x1e, 0x7e, 0x45, 0x30, 0xb9,
0xdd, 0x53, 0x51, 0x13, 0xfa, 0x65, 0x4f, 0x2b, 0x89, 0x43, 0x18, 0x56, 0x94, 0x65, 0x54, 0xf8,
0x68, 0x8e, 0x16, 0xe3, 0x25, 0x44, 0x9a, 0xbe, 0xe1, 0x19, 0x25, 0x46, 0x51, 0x8c, 0x4c, 0x45,
0x4e, 0xa5, 0x6f, 0xfd, 0xce, 0x34, 0x0a, 0x3e, 0x85, 0xc1, 0xae, 0xf8, 0x5c, 0x48, 0xdf, 0x9e,
0xa3, 0x85, 0x4d, 0x1a, 0x03, 0x07, 0xe0, 0x96, 0x05, 0xcb, 0x37, 0xe9, 0xf6, 0x93, 0xef, 0xcc,
0xd1, 0xc2, 0x25, 0x9d, 0x1d, 0xbe, 0x87, 0xa9, 0xa9, 0xa4, 0x2a, 0x39, 0xab, 0xe8, 0x3f, 0x95,
0xf2, 0x00, 0x5c, 0x61, 0x78, 0xdf, 0x9a, 0xdb, 0x47, 0x54, 0xa7, 0x85, 0x53, 0x18, 0xbf, 0x2e,
0x58, 0x6e, 0xba, 0x0c, 0x67, 0x30, 0x69, 0xcc, 0x83, 0xbc, 0x66, 0x1f, 0x79, 0x2b, 0x7f, 0x43,
0x30, 0x69, 0xec, 0xae, 0x14, 0x47, 0xd6, 0x25, 0xd5, 0xfd, 0xce, 0x96, 0xb3, 0x43, 0x8a, 0xa4,
0x2e, 0x29, 0xd1, 0x1a, 0x8e, 0xc0, 0xe5, 0x25, 0x15, 0xa9, 0xe4, 0x42, 0x37, 0x3d, 0x5e, 0xe2,
0x03, 0xf7, 0xca, 0x28, 0xa4, 0x63, 0x14, 0xbf, 0x4d, 0xcb, 0x74, 0x5b, 0xc8, 0x5a, 0xbf, 0xc5,
0x2f, 0xfc, 0x33, 0xa3, 0x90, 0x8e, 0x09, 0x7f, 0x20, 0x18, 0x13, 0x5a, 0x49, 0x51, 0x6c, 0x65,
0xc1, 0x19, 0x7e, 0xdc, 0xcb, 0x87, 0x74, 0x5d, 0xf7, 0xa3, 0x76, 0xfa, 0x3d, 0x2e, 0xfa, 0x43,
0xea, 0x0b, 0x18, 0xe9, 0x3b, 0xcb, 0x4c, 0x47, 0xf7, 0xfe, 0x1e, 0xc9, 0x32, 0xd2, 0xc2, 0x6a,
0xa8, 0x77, 0xe9, 0x6e, 0x4f, 0xdb, 0xa1, 0x6a, 0x23, 0x7c, 0x04, 0x6e, 0x9b, 0x03, 0x0f, 0xc1,
0xba, 0x4e, 0xbc, 0x13, 0x75, 0xc6, 0xb7, 0x1e, 0x52, 0xe7, 0x55, 0xe2, 0x59, 0x78, 0x04, 0xf6,
0x75, 0x12, 0x7b, 0xb6, 0xba, 0x5c, 0x25, 0xb1, 0xe7, 0x84, 0x0f, 0x61, 0x64, 0xbe, 0x8f, 0x31,
0xcc, 0x9e, 0x93, 0x38, 0xfe, 0x70, 0xf9, 0xf4, 0x66, 0xf5, 0x76, 0xbd, 0x4a, 0x5e, 0x78, 0x27,
0x78, 0x0a, 0xff, 0x69, 0xdf, 0x6a, 0xfd, 0xe6, 0xa5, 0x87, 0x96, 0xdf, 0x11, 0x0c, 0xd4, 0xbb,
0x54, 0xf8, 0x02, 0x06, 0x7a, 0x4d, 0xf0, 0x59, 0x57, 0x73, 0x7f, 0x81, 0x83, 0xff, 0x8f, 0xdd,
0x66, 0x84, 0xe7, 0xe0, 0xa8, 0x91, 0xe3, 0xd3, 0x4e, 0xef, 0x2d, 0x44, 0x70, 0x76, 0xe4, 0x35,
0x41, 0x4f, 0xd4, 0x93, 0x6b, 0x42, 0xad, 0x43, 0x2f, 0xb6, 0xb7, 0x2d, 0xbd, 0xd8, 0xfe, 0xce,
0x5c, 0x3a, 0xef, 0xac, 0x72, 0xb3, 0x19, 0xea, 0xff, 0xec, 0xfc, 0x67, 0x00, 0x00, 0x00, 0xff,
0xff, 0x33, 0xe5, 0x71, 0x1b, 0x99, 0x03, 0x00, 0x00,
// 491 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0xdf, 0x8a, 0xd3, 0x40,
0x14, 0xc6, 0x77, 0xda, 0x74, 0x13, 0x4f, 0xff, 0x10, 0x87, 0x5d, 0x09, 0x41, 0xa1, 0xe4, 0x42,
0x0a, 0x4a, 0x2e, 0xba, 0xb2, 0xa0, 0x77, 0xae, 0x8d, 0x6b, 0x71, 0x59, 0xdd, 0x31, 0x28, 0xe8,
0x85, 0xa4, 0xcd, 0x18, 0x82, 0x75, 0x26, 0x4e, 0xa6, 0x85, 0xbc, 0x81, 0x8f, 0xe3, 0x1b, 0xf8,
0x5e, 0x5e, 0xc9, 0x4c, 0x26, 0x69, 0xac, 0x0a, 0x5e, 0xcd, 0x9c, 0xf3, 0xfd, 0x4e, 0xe7, 0x9c,
0xd3, 0x2f, 0x30, 0xe6, 0x3b, 0x2a, 0x36, 0x49, 0x15, 0x16, 0x82, 0x4b, 0x8e, 0x6d, 0x13, 0xfa,
0x90, 0xf1, 0x8c, 0xd7, 0x49, 0x1f, 0x18, 0x4f, 0x69, 0x7d, 0x0f, 0xbe, 0x21, 0x18, 0xdd, 0x6c,
0xa9, 0xa8, 0x08, 0xfd, 0xba, 0xa5, 0xa5, 0xc4, 0x01, 0x1c, 0x97, 0x94, 0xa5, 0x54, 0x78, 0x68,
0x8a, 0x66, 0xc3, 0x39, 0x84, 0x9a, 0xbe, 0xe6, 0x29, 0x25, 0x46, 0x51, 0x8c, 0x4c, 0x44, 0x46,
0xa5, 0xd7, 0xfb, 0x93, 0xa9, 0x15, 0x7c, 0x02, 0x83, 0x4d, 0xfe, 0x25, 0x97, 0x5e, 0x7f, 0x8a,
0x66, 0x7d, 0x52, 0x07, 0xd8, 0x07, 0xa7, 0xc8, 0x59, 0xb6, 0x4a, 0xd6, 0x9f, 0x3d, 0x6b, 0x8a,
0x66, 0x0e, 0x69, 0xe3, 0xe0, 0x03, 0x8c, 0x4d, 0x27, 0x65, 0xc1, 0x59, 0x49, 0xff, 0xab, 0x95,
0xfb, 0xe0, 0x08, 0xc3, 0x7b, 0xbd, 0x69, 0xff, 0x80, 0x6a, 0xb5, 0x60, 0x0c, 0xc3, 0xd7, 0x39,
0xcb, 0xcc, 0x94, 0xc1, 0x04, 0x46, 0x75, 0xb8, 0x97, 0x97, 0xec, 0x13, 0x6f, 0xe4, 0x1f, 0x08,
0x46, 0x75, 0xdc, 0xb6, 0x62, 0xc9, 0xaa, 0xa0, 0x7a, 0xde, 0xc9, 0x7c, 0xb2, 0x7f, 0x22, 0xae,
0x0a, 0x4a, 0xb4, 0x86, 0x43, 0x70, 0x78, 0x41, 0x45, 0x22, 0xb9, 0xd0, 0x43, 0x0f, 0xe7, 0x78,
0xcf, 0xbd, 0x32, 0x0a, 0x69, 0x19, 0xc5, 0xaf, 0x93, 0x22, 0x59, 0xe7, 0xb2, 0xd2, 0xbb, 0xf8,
0x8d, 0x7f, 0x66, 0x14, 0xd2, 0x32, 0xf8, 0x01, 0xd8, 0x3b, 0x2a, 0xca, 0x9c, 0x33, 0x6f, 0xa0,
0xf1, 0xdb, 0x7b, 0xfc, 0x6d, 0x2d, 0x90, 0x86, 0x08, 0x7e, 0x22, 0x18, 0x12, 0x5a, 0x4a, 0x91,
0xaf, 0x65, 0xce, 0x19, 0x7e, 0xdc, 0x69, 0x0e, 0xe9, 0x21, 0xee, 0x85, 0x8d, 0x55, 0x3a, 0x5c,
0xf8, 0x97, 0x3e, 0xcf, 0xc1, 0xd6, 0x77, 0x96, 0x9a, 0xf1, 0xef, 0xfe, 0xbb, 0x92, 0xa5, 0xa4,
0x81, 0x95, 0x03, 0x76, 0xc9, 0x66, 0x4b, 0x1b, 0x07, 0xe8, 0x20, 0x78, 0x04, 0x4e, 0xf3, 0x06,
0x3e, 0x86, 0xde, 0x55, 0xec, 0x1e, 0xa9, 0x33, 0xba, 0x71, 0x91, 0x3a, 0x2f, 0x63, 0xb7, 0x87,
0x6d, 0xe8, 0x5f, 0xc5, 0x91, 0xdb, 0x57, 0x97, 0xcb, 0x38, 0x72, 0xad, 0xe0, 0x21, 0xd8, 0xe6,
0xf7, 0x31, 0x86, 0xc9, 0x73, 0x12, 0x45, 0x1f, 0x2f, 0x9e, 0x5e, 0x2f, 0xde, 0x2d, 0x17, 0xf1,
0x0b, 0xf7, 0x08, 0x8f, 0xe1, 0x96, 0xce, 0x2d, 0x96, 0x6f, 0x5e, 0xba, 0x68, 0xfe, 0x1d, 0xc1,
0x40, 0x6d, 0xa5, 0xc4, 0xe7, 0x30, 0xd0, 0x9e, 0xc2, 0xa7, 0x6d, 0xcf, 0x5d, 0xb7, 0xfb, 0x77,
0x0e, 0xd3, 0xe6, 0xff, 0x3e, 0x03, 0x4b, 0xf9, 0x03, 0x9f, 0xb4, 0x7a, 0xc7, 0x3d, 0xfe, 0xe9,
0x41, 0xd6, 0x14, 0x3d, 0x51, 0x2b, 0xd7, 0x84, 0xf2, 0x4e, 0xa7, 0xb6, 0x63, 0xad, 0x4e, 0x6d,
0xd7, 0x60, 0x17, 0xd6, 0xfb, 0x5e, 0xb1, 0x5a, 0x1d, 0xeb, 0x8f, 0xf2, 0xec, 0x57, 0x00, 0x00,
0x00, 0xff, 0xff, 0x6b, 0xb9, 0x2c, 0xac, 0xc6, 0x03, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

1
pkg/pb/overlay.proto
View File

@ -37,6 +37,7 @@ message InfoResponse {
node.NodeType type = 2;
node.NodeOperator operator = 3;
node.NodeCapacity capacity = 4;
node.NodeVersion version = 5;
}
message Restriction {

17
satellite/peer.go
View File

@ -229,16 +229,7 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB, config *Config, ve
log.Debug("Starting overlay")
config := config.Overlay
nodeSelectionConfig := overlay.NodeSelectionConfig{
UptimeCount: config.Node.UptimeCount,
UptimeRatio: config.Node.UptimeRatio,
AuditSuccessRatio: config.Node.AuditSuccessRatio,
AuditCount: config.Node.AuditCount,
NewNodeAuditThreshold: config.Node.NewNodeAuditThreshold,
NewNodePercentage: config.Node.NewNodePercentage,
}
peer.Overlay.Service = overlay.NewCache(peer.Log.Named("overlay"), peer.DB.OverlayCache(), nodeSelectionConfig)
peer.Overlay.Service = overlay.NewCache(peer.Log.Named("overlay"), peer.DB.OverlayCache(), config.Node)
peer.Transport = peer.Transport.WithObservers(peer.Overlay.Service)
peer.Overlay.Inspector = overlay.NewInspector(peer.Overlay.Service)
@ -253,6 +244,11 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB, config *Config, ve
config.ExternalAddress = peer.Addr()
}
pbVersion, err := versionInfo.Proto()
if err != nil {
return nil, errs.Combine(err, peer.Close())
}
self := pb.Node{
Id: peer.ID(),
Type: pb.NodeType_SATELLITE,
@ -262,6 +258,7 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB, config *Config, ve
Metadata: &pb.NodeMetadata{
Wallet: config.Operator.Wallet,
},
Version: pbVersion,
}
{ // setup routing table

19
satellite/satellitedb/dbx/satellitedb.dbx
View File

@ -36,9 +36,9 @@ read one (
where irreparabledb.segmentpath = ?
)
read limitoffset (
select irreparabledb
orderby asc irreparabledb.segmentpath
read limitoffset (
select irreparabledb
orderby asc irreparabledb.segmentpath
)
//--- accounting ---//
@ -68,7 +68,7 @@ model accounting_rollup (
field put_total int64
field get_total int64
field get_audit_total int64
field get_repair_total int64
field get_repair_total int64
field put_repair_total int64
field at_rest_total float64
)
@ -128,6 +128,13 @@ model node (
field free_bandwidth int64 ( updatable )
field free_disk int64 ( updatable )
field major int64 ( updatable )
field minor int64 ( updatable )
field patch int64 ( updatable )
field hash text ( updatable )
field timestamp timestamp ( updatable )
field release bool ( updatable )
field latency_90 int64 ( updatable )
field audit_success_count int64 ( updatable )
field total_audit_count int64 ( updatable )
@ -428,7 +435,7 @@ model bucket_storage_tally (
field inline uint64
field remote uint64
field remote_segments_count uint
field inline_segments_count uint
field object_count uint
@ -495,7 +502,7 @@ model storagenode_storage_tally (
//--- certRecord ---//
model certRecord (
key id
key id
field publickey blob //--uplink public key--//
field id blob //--uplink node id --//

329
satellite/satellitedb/dbx/satellitedb.dbx.go
View File

@ -10,6 +10,7 @@ import (
"errors"
"fmt"
"reflect"
"regexp"
"strconv"
"strings"
"sync"
@ -374,6 +375,12 @@ CREATE TABLE nodes (
wallet text NOT NULL,
free_bandwidth bigint NOT NULL,
free_disk bigint NOT NULL,
major bigint NOT NULL,
minor bigint NOT NULL,
patch bigint NOT NULL,
hash text NOT NULL,
timestamp timestamp with time zone NOT NULL,
release boolean NOT NULL,
latency_90 bigint NOT NULL,
audit_success_count bigint NOT NULL,
total_audit_count bigint NOT NULL,
@ -625,6 +632,12 @@ CREATE TABLE nodes (
wallet TEXT NOT NULL,
free_bandwidth INTEGER NOT NULL,
free_disk INTEGER NOT NULL,
major INTEGER NOT NULL,
minor INTEGER NOT NULL,
patch INTEGER NOT NULL,
hash TEXT NOT NULL,
timestamp TIMESTAMP NOT NULL,
release INTEGER NOT NULL,
latency_90 INTEGER NOT NULL,
audit_success_count INTEGER NOT NULL,
total_audit_count INTEGER NOT NULL,
@ -2132,6 +2145,12 @@ type Node struct {
Wallet string
FreeBandwidth int64
FreeDisk int64
Major int64
Minor int64
Patch int64
Hash string
Timestamp time.Time
Release bool
Latency90 int64
AuditSuccessCount int64
TotalAuditCount int64
@ -2155,6 +2174,12 @@ type Node_Update_Fields struct {
Wallet Node_Wallet_Field
FreeBandwidth Node_FreeBandwidth_Field
FreeDisk Node_FreeDisk_Field
Major Node_Major_Field
Minor Node_Minor_Field
Patch Node_Patch_Field
Hash Node_Hash_Field
Timestamp Node_Timestamp_Field
Release Node_Release_Field
Latency90 Node_Latency90_Field
AuditSuccessCount Node_AuditSuccessCount_Field
TotalAuditCount Node_TotalAuditCount_Field
@ -2318,6 +2343,120 @@ func (f Node_FreeDisk_Field) value() interface{} {
func (Node_FreeDisk_Field) _Column() string { return "free_disk" }
type Node_Major_Field struct {
_set bool
_null bool
_value int64
}
func Node_Major(v int64) Node_Major_Field {
return Node_Major_Field{_set: true, _value: v}
}
func (f Node_Major_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (Node_Major_Field) _Column() string { return "major" }
type Node_Minor_Field struct {
_set bool
_null bool
_value int64
}
func Node_Minor(v int64) Node_Minor_Field {
return Node_Minor_Field{_set: true, _value: v}
}
func (f Node_Minor_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (Node_Minor_Field) _Column() string { return "minor" }
type Node_Patch_Field struct {
_set bool
_null bool
_value int64
}
func Node_Patch(v int64) Node_Patch_Field {
return Node_Patch_Field{_set: true, _value: v}
}
func (f Node_Patch_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (Node_Patch_Field) _Column() string { return "patch" }
type Node_Hash_Field struct {
_set bool
_null bool
_value string
}
func Node_Hash(v string) Node_Hash_Field {
return Node_Hash_Field{_set: true, _value: v}
}
func (f Node_Hash_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (Node_Hash_Field) _Column() string { return "hash" }
type Node_Timestamp_Field struct {
_set bool
_null bool
_value time.Time
}
func Node_Timestamp(v time.Time) Node_Timestamp_Field {
return Node_Timestamp_Field{_set: true, _value: v}
}
func (f Node_Timestamp_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (Node_Timestamp_Field) _Column() string { return "timestamp" }
type Node_Release_Field struct {
_set bool
_null bool
_value bool
}
func Node_Release(v bool) Node_Release_Field {
return Node_Release_Field{_set: true, _value: v}
}
func (f Node_Release_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (Node_Release_Field) _Column() string { return "release" }
type Node_Latency90_Field struct {
_set bool
_null bool
@ -3461,54 +3600,10 @@ func __sqlbundle_Render(dialect __sqlbundle_Dialect, sql __sqlbundle_SQL, ops ..
return dialect.Rebind(out)
}
func __sqlbundle_flattenSQL(x string) string {
// trim whitespace from beginning and end
s, e := 0, len(x)-1
for s < len(x) && (x[s] == ' ' || x[s] == '\t' || x[s] == '\n') {
s++
}
for s <= e && (x[e] == ' ' || x[e] == '\t' || x[e] == '\n') {
e--
}
if s > e {
return ""
}
x = x[s : e+1]
var __sqlbundle_reSpace = regexp.MustCompile(`\s+`)
// check for whitespace that needs fixing
wasSpace := false
for i := 0; i < len(x); i++ {
r := x[i]
justSpace := r == ' '
if (wasSpace && justSpace) || r == '\t' || r == '\n' {
// whitespace detected, start writing a new string
var result strings.Builder
result.Grow(len(x))
if wasSpace {
result.WriteString(x[:i-1])
} else {
result.WriteString(x[:i])
}
for p := i; p < len(x); p++ {
for p < len(x) && (x[p] == ' ' || x[p] == '\t' || x[p] == '\n') {
p++
}
result.WriteByte(' ')
start := p
for p < len(x) && !(x[p] == ' ' || x[p] == '\t' || x[p] == '\n') {
p++
}
result.WriteString(x[start:p])
}
return result.String()
}
wasSpace = justSpace
}
// no problematic whitespace found
return x
func __sqlbundle_flattenSQL(s string) string {
return strings.TrimSpace(__sqlbundle_reSpace.ReplaceAllString(s, " "))
}
// this type is specially named to match up with the name returned by the
@ -3587,8 +3682,6 @@ type __sqlbundle_Condition struct {
func (*__sqlbundle_Condition) private() {}
func (c *__sqlbundle_Condition) Render() string {
// TODO(jeff): maybe check if we can use placeholders instead of the
// literal null: this would make the templates easier.
switch {
case c.Equal && c.Null:
@ -3745,6 +3838,12 @@ func (obj *postgresImpl) Create_Node(ctx context.Context,
node_wallet Node_Wallet_Field,
node_free_bandwidth Node_FreeBandwidth_Field,
node_free_disk Node_FreeDisk_Field,
node_major Node_Major_Field,
node_minor Node_Minor_Field,
node_patch Node_Patch_Field,
node_hash Node_Hash_Field,
node_timestamp Node_Timestamp_Field,
node_release Node_Release_Field,
node_latency_90 Node_Latency90_Field,
node_audit_success_count Node_AuditSuccessCount_Field,
node_total_audit_count Node_TotalAuditCount_Field,
@ -3765,6 +3864,12 @@ func (obj *postgresImpl) Create_Node(ctx context.Context,
__wallet_val := node_wallet.value()
__free_bandwidth_val := node_free_bandwidth.value()
__free_disk_val := node_free_disk.value()
__major_val := node_major.value()
__minor_val := node_minor.value()
__patch_val := node_patch.value()
__hash_val := node_hash.value()
__timestamp_val := node_timestamp.value()
__release_val := node_release.value()
__latency_90_val := node_latency_90.value()
__audit_success_count_val := node_audit_success_count.value()
__total_audit_count_val := node_total_audit_count.value()
@ -3777,13 +3882,13 @@ func (obj *postgresImpl) Create_Node(ctx context.Context,
__last_contact_success_val := node_last_contact_success.value()
__last_contact_failure_val := node_last_contact_failure.value()
var __embed_stmt = __sqlbundle_Literal("INSERT INTO nodes ( id, address, protocol, type, email, wallet, free_bandwidth, free_disk, latency_90, audit_success_count, total_audit_count, audit_success_ratio, uptime_success_count, total_uptime_count, uptime_ratio, created_at, updated_at, last_contact_success, last_contact_failure ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ) RETURNING nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure")
var __embed_stmt = __sqlbundle_Literal("INSERT INTO nodes ( id, address, protocol, type, email, wallet, free_bandwidth, free_disk, major, minor, patch, hash, timestamp, release, latency_90, audit_success_count, total_audit_count, audit_success_ratio, uptime_success_count, total_uptime_count, uptime_ratio, created_at, updated_at, last_contact_success, last_contact_failure ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ) RETURNING nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.major, nodes.minor, nodes.patch, nodes.hash, nodes.timestamp, nodes.release, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure")
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, __id_val, __address_val, __protocol_val, __type_val, __email_val, __wallet_val, __free_bandwidth_val, __free_disk_val, __latency_90_val, __audit_success_count_val, __total_audit_count_val, __audit_success_ratio_val, __uptime_success_count_val, __total_uptime_count_val, __uptime_ratio_val, __created_at_val, __updated_at_val, __last_contact_success_val, __last_contact_failure_val)
obj.logStmt(__stmt, __id_val, __address_val, __protocol_val, __type_val, __email_val, __wallet_val, __free_bandwidth_val, __free_disk_val, __major_val, __minor_val, __patch_val, __hash_val, __timestamp_val, __release_val, __latency_90_val, __audit_success_count_val, __total_audit_count_val, __audit_success_ratio_val, __uptime_success_count_val, __total_uptime_count_val, __uptime_ratio_val, __created_at_val, __updated_at_val, __last_contact_success_val, __last_contact_failure_val)
node = &Node{}
err = obj.driver.QueryRow(__stmt, __id_val, __address_val, __protocol_val, __type_val, __email_val, __wallet_val, __free_bandwidth_val, __free_disk_val, __latency_90_val, __audit_success_count_val, __total_audit_count_val, __audit_success_ratio_val, __uptime_success_count_val, __total_uptime_count_val, __uptime_ratio_val, __created_at_val, __updated_at_val, __last_contact_success_val, __last_contact_failure_val).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
err = obj.driver.QueryRow(__stmt, __id_val, __address_val, __protocol_val, __type_val, __email_val, __wallet_val, __free_bandwidth_val, __free_disk_val, __major_val, __minor_val, __patch_val, __hash_val, __timestamp_val, __release_val, __latency_90_val, __audit_success_count_val, __total_audit_count_val, __audit_success_ratio_val, __uptime_success_count_val, __total_uptime_count_val, __uptime_ratio_val, __created_at_val, __updated_at_val, __last_contact_success_val, __last_contact_failure_val).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Major, &node.Minor, &node.Patch, &node.Hash, &node.Timestamp, &node.Release, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
if err != nil {
return nil, obj.makeErr(err)
}
@ -4313,7 +4418,7 @@ func (obj *postgresImpl) Get_Node_By_Id(ctx context.Context,
node_id Node_Id_Field) (
node *Node, err error) {
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id = ?")
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.major, nodes.minor, nodes.patch, nodes.hash, nodes.timestamp, nodes.release, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id = ?")
var __values []interface{}
__values = append(__values, node_id.value())
@ -4322,7 +4427,7 @@ func (obj *postgresImpl) Get_Node_By_Id(ctx context.Context,
obj.logStmt(__stmt, __values...)
node = &Node{}
err = obj.driver.QueryRow(__stmt, __values...).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
err = obj.driver.QueryRow(__stmt, __values...).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Major, &node.Minor, &node.Patch, &node.Hash, &node.Timestamp, &node.Release, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
if err != nil {
return nil, obj.makeErr(err)
}
@ -4367,7 +4472,7 @@ func (obj *postgresImpl) Limited_Node_By_Id_GreaterOrEqual_OrderBy_Asc_Id(ctx co
limit int, offset int64) (
rows []*Node, err error) {
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id >= ? ORDER BY nodes.id LIMIT ? OFFSET ?")
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.major, nodes.minor, nodes.patch, nodes.hash, nodes.timestamp, nodes.release, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id >= ? ORDER BY nodes.id LIMIT ? OFFSET ?")
var __values []interface{}
__values = append(__values, node_id_greater_or_equal.value())
@ -4385,7 +4490,7 @@ func (obj *postgresImpl) Limited_Node_By_Id_GreaterOrEqual_OrderBy_Asc_Id(ctx co
for __rows.Next() {
node := &Node{}
err = __rows.Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
err = __rows.Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Major, &node.Minor, &node.Patch, &node.Hash, &node.Timestamp, &node.Release, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
if err != nil {
return nil, obj.makeErr(err)
}
@ -5229,7 +5334,7 @@ func (obj *postgresImpl) Update_Node_By_Id(ctx context.Context,
node *Node, err error) {
var __sets = &__sqlbundle_Hole{}
var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE nodes SET "), __sets, __sqlbundle_Literal(" WHERE nodes.id = ? RETURNING nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure")}}
var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE nodes SET "), __sets, __sqlbundle_Literal(" WHERE nodes.id = ? RETURNING nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.major, nodes.minor, nodes.patch, nodes.hash, nodes.timestamp, nodes.release, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure")}}
__sets_sql := __sqlbundle_Literals{Join: ", "}
var __values []interface{}
@ -5270,6 +5375,36 @@ func (obj *postgresImpl) Update_Node_By_Id(ctx context.Context,
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("free_disk = ?"))
}
if update.Major._set {
__values = append(__values, update.Major.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("major = ?"))
}
if update.Minor._set {
__values = append(__values, update.Minor.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("minor = ?"))
}
if update.Patch._set {
__values = append(__values, update.Patch.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("patch = ?"))
}
if update.Hash._set {
__values = append(__values, update.Hash.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("hash = ?"))
}
if update.Timestamp._set {
__values = append(__values, update.Timestamp.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("timestamp = ?"))
}
if update.Release._set {
__values = append(__values, update.Release.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("release = ?"))
}
if update.Latency90._set {
__values = append(__values, update.Latency90.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("latency_90 = ?"))
@ -5329,7 +5464,7 @@ func (obj *postgresImpl) Update_Node_By_Id(ctx context.Context,
obj.logStmt(__stmt, __values...)
node = &Node{}
err = obj.driver.QueryRow(__stmt, __values...).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
err = obj.driver.QueryRow(__stmt, __values...).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Major, &node.Minor, &node.Patch, &node.Hash, &node.Timestamp, &node.Release, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
if err == sql.ErrNoRows {
return nil, nil
}
@ -6215,6 +6350,12 @@ func (obj *sqlite3Impl) Create_Node(ctx context.Context,
node_wallet Node_Wallet_Field,
node_free_bandwidth Node_FreeBandwidth_Field,
node_free_disk Node_FreeDisk_Field,
node_major Node_Major_Field,
node_minor Node_Minor_Field,
node_patch Node_Patch_Field,
node_hash Node_Hash_Field,
node_timestamp Node_Timestamp_Field,
node_release Node_Release_Field,
node_latency_90 Node_Latency90_Field,
node_audit_success_count Node_AuditSuccessCount_Field,
node_total_audit_count Node_TotalAuditCount_Field,
@ -6235,6 +6376,12 @@ func (obj *sqlite3Impl) Create_Node(ctx context.Context,
__wallet_val := node_wallet.value()
__free_bandwidth_val := node_free_bandwidth.value()
__free_disk_val := node_free_disk.value()
__major_val := node_major.value()
__minor_val := node_minor.value()
__patch_val := node_patch.value()
__hash_val := node_hash.value()
__timestamp_val := node_timestamp.value()
__release_val := node_release.value()
__latency_90_val := node_latency_90.value()
__audit_success_count_val := node_audit_success_count.value()
__total_audit_count_val := node_total_audit_count.value()
@ -6247,12 +6394,12 @@ func (obj *sqlite3Impl) Create_Node(ctx context.Context,
__last_contact_success_val := node_last_contact_success.value()
__last_contact_failure_val := node_last_contact_failure.value()
var __embed_stmt = __sqlbundle_Literal("INSERT INTO nodes ( id, address, protocol, type, email, wallet, free_bandwidth, free_disk, latency_90, audit_success_count, total_audit_count, audit_success_ratio, uptime_success_count, total_uptime_count, uptime_ratio, created_at, updated_at, last_contact_success, last_contact_failure ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )")
var __embed_stmt = __sqlbundle_Literal("INSERT INTO nodes ( id, address, protocol, type, email, wallet, free_bandwidth, free_disk, major, minor, patch, hash, timestamp, release, latency_90, audit_success_count, total_audit_count, audit_success_ratio, uptime_success_count, total_uptime_count, uptime_ratio, created_at, updated_at, last_contact_success, last_contact_failure ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )")
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, __id_val, __address_val, __protocol_val, __type_val, __email_val, __wallet_val, __free_bandwidth_val, __free_disk_val, __latency_90_val, __audit_success_count_val, __total_audit_count_val, __audit_success_ratio_val, __uptime_success_count_val, __total_uptime_count_val, __uptime_ratio_val, __created_at_val, __updated_at_val, __last_contact_success_val, __last_contact_failure_val)
obj.logStmt(__stmt, __id_val, __address_val, __protocol_val, __type_val, __email_val, __wallet_val, __free_bandwidth_val, __free_disk_val, __major_val, __minor_val, __patch_val, __hash_val, __timestamp_val, __release_val, __latency_90_val, __audit_success_count_val, __total_audit_count_val, __audit_success_ratio_val, __uptime_success_count_val, __total_uptime_count_val, __uptime_ratio_val, __created_at_val, __updated_at_val, __last_contact_success_val, __last_contact_failure_val)
__res, err := obj.driver.Exec(__stmt, __id_val, __address_val, __protocol_val, __type_val, __email_val, __wallet_val, __free_bandwidth_val, __free_disk_val, __latency_90_val, __audit_success_count_val, __total_audit_count_val, __audit_success_ratio_val, __uptime_success_count_val, __total_uptime_count_val, __uptime_ratio_val, __created_at_val, __updated_at_val, __last_contact_success_val, __last_contact_failure_val)
__res, err := obj.driver.Exec(__stmt, __id_val, __address_val, __protocol_val, __type_val, __email_val, __wallet_val, __free_bandwidth_val, __free_disk_val, __major_val, __minor_val, __patch_val, __hash_val, __timestamp_val, __release_val, __latency_90_val, __audit_success_count_val, __total_audit_count_val, __audit_success_ratio_val, __uptime_success_count_val, __total_uptime_count_val, __uptime_ratio_val, __created_at_val, __updated_at_val, __last_contact_success_val, __last_contact_failure_val)
if err != nil {
return nil, obj.makeErr(err)
}
@ -6819,7 +6966,7 @@ func (obj *sqlite3Impl) Get_Node_By_Id(ctx context.Context,
node_id Node_Id_Field) (
node *Node, err error) {
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id = ?")
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.major, nodes.minor, nodes.patch, nodes.hash, nodes.timestamp, nodes.release, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id = ?")
var __values []interface{}
__values = append(__values, node_id.value())
@ -6828,7 +6975,7 @@ func (obj *sqlite3Impl) Get_Node_By_Id(ctx context.Context,
obj.logStmt(__stmt, __values...)
node = &Node{}
err = obj.driver.QueryRow(__stmt, __values...).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
err = obj.driver.QueryRow(__stmt, __values...).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Major, &node.Minor, &node.Patch, &node.Hash, &node.Timestamp, &node.Release, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
if err != nil {
return nil, obj.makeErr(err)
}
@ -6873,7 +7020,7 @@ func (obj *sqlite3Impl) Limited_Node_By_Id_GreaterOrEqual_OrderBy_Asc_Id(ctx con
limit int, offset int64) (
rows []*Node, err error) {
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id >= ? ORDER BY nodes.id LIMIT ? OFFSET ?")
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.major, nodes.minor, nodes.patch, nodes.hash, nodes.timestamp, nodes.release, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id >= ? ORDER BY nodes.id LIMIT ? OFFSET ?")
var __values []interface{}
__values = append(__values, node_id_greater_or_equal.value())
@ -6891,7 +7038,7 @@ func (obj *sqlite3Impl) Limited_Node_By_Id_GreaterOrEqual_OrderBy_Asc_Id(ctx con
for __rows.Next() {
node := &Node{}
err = __rows.Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
err = __rows.Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Major, &node.Minor, &node.Patch, &node.Hash, &node.Timestamp, &node.Release, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
if err != nil {
return nil, obj.makeErr(err)
}
@ -7796,6 +7943,36 @@ func (obj *sqlite3Impl) Update_Node_By_Id(ctx context.Context,
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("free_disk = ?"))
}
if update.Major._set {
__values = append(__values, update.Major.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("major = ?"))
}
if update.Minor._set {
__values = append(__values, update.Minor.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("minor = ?"))
}
if update.Patch._set {
__values = append(__values, update.Patch.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("patch = ?"))
}
if update.Hash._set {
__values = append(__values, update.Hash.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("hash = ?"))
}
if update.Timestamp._set {
__values = append(__values, update.Timestamp.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("timestamp = ?"))
}
if update.Release._set {
__values = append(__values, update.Release.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("release = ?"))
}
if update.Latency90._set {
__values = append(__values, update.Latency90.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("latency_90 = ?"))
@ -7860,12 +8037,12 @@ func (obj *sqlite3Impl) Update_Node_By_Id(ctx context.Context,
return nil, obj.makeErr(err)
}
var __embed_stmt_get = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id = ?")
var __embed_stmt_get = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.major, nodes.minor, nodes.patch, nodes.hash, nodes.timestamp, nodes.release, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE nodes.id = ?")
var __stmt_get = __sqlbundle_Render(obj.dialect, __embed_stmt_get)
obj.logStmt("(IMPLIED) "+__stmt_get, __args...)
err = obj.driver.QueryRow(__stmt_get, __args...).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
err = obj.driver.QueryRow(__stmt_get, __args...).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Major, &node.Minor, &node.Patch, &node.Hash, &node.Timestamp, &node.Release, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
if err == sql.ErrNoRows {
return nil, nil
}
@ -8530,13 +8707,13 @@ func (obj *sqlite3Impl) getLastNode(ctx context.Context,
pk int64) (
node *Node, err error) {
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE _rowid_ = ?")
var __embed_stmt = __sqlbundle_Literal("SELECT nodes.id, nodes.address, nodes.protocol, nodes.type, nodes.email, nodes.wallet, nodes.free_bandwidth, nodes.free_disk, nodes.major, nodes.minor, nodes.patch, nodes.hash, nodes.timestamp, nodes.release, nodes.latency_90, nodes.audit_success_count, nodes.total_audit_count, nodes.audit_success_ratio, nodes.uptime_success_count, nodes.total_uptime_count, nodes.uptime_ratio, nodes.created_at, nodes.updated_at, nodes.last_contact_success, nodes.last_contact_failure FROM nodes WHERE _rowid_ = ?")
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, pk)
node = &Node{}
err = obj.driver.QueryRow(__stmt, pk).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
err = obj.driver.QueryRow(__stmt, pk).Scan(&node.Id, &node.Address, &node.Protocol, &node.Type, &node.Email, &node.Wallet, &node.FreeBandwidth, &node.FreeDisk, &node.Major, &node.Minor, &node.Patch, &node.Hash, &node.Timestamp, &node.Release, &node.Latency90, &node.AuditSuccessCount, &node.TotalAuditCount, &node.AuditSuccessRatio, &node.UptimeSuccessCount, &node.TotalUptimeCount, &node.UptimeRatio, &node.CreatedAt, &node.UpdatedAt, &node.LastContactSuccess, &node.LastContactFailure)
if err != nil {
return nil, obj.makeErr(err)
}
@ -9254,6 +9431,12 @@ func (rx *Rx) Create_Node(ctx context.Context,
node_wallet Node_Wallet_Field,
node_free_bandwidth Node_FreeBandwidth_Field,
node_free_disk Node_FreeDisk_Field,
node_major Node_Major_Field,
node_minor Node_Minor_Field,
node_patch Node_Patch_Field,
node_hash Node_Hash_Field,
node_timestamp Node_Timestamp_Field,
node_release Node_Release_Field,
node_latency_90 Node_Latency90_Field,
node_audit_success_count Node_AuditSuccessCount_Field,
node_total_audit_count Node_TotalAuditCount_Field,
@ -9268,7 +9451,7 @@ func (rx *Rx) Create_Node(ctx context.Context,
if tx, err = rx.getTx(ctx); err != nil {
return
}
return tx.Create_Node(ctx, node_id, node_address, node_protocol, node_type, node_email, node_wallet, node_free_bandwidth, node_free_disk, node_latency_90, node_audit_success_count, node_total_audit_count, node_audit_success_ratio, node_uptime_success_count, node_total_uptime_count, node_uptime_ratio, node_last_contact_success, node_last_contact_failure)
return tx.Create_Node(ctx, node_id, node_address, node_protocol, node_type, node_email, node_wallet, node_free_bandwidth, node_free_disk, node_major, node_minor, node_patch, node_hash, node_timestamp, node_release, node_latency_90, node_audit_success_count, node_total_audit_count, node_audit_success_ratio, node_uptime_success_count, node_total_uptime_count, node_uptime_ratio, node_last_contact_success, node_last_contact_failure)
}
@ -9947,6 +10130,12 @@ type Methods interface {
node_wallet Node_Wallet_Field,
node_free_bandwidth Node_FreeBandwidth_Field,
node_free_disk Node_FreeDisk_Field,
node_major Node_Major_Field,
node_minor Node_Minor_Field,
node_patch Node_Patch_Field,
node_hash Node_Hash_Field,
node_timestamp Node_Timestamp_Field,
node_release Node_Release_Field,
node_latency_90 Node_Latency90_Field,
node_audit_success_count Node_AuditSuccessCount_Field,
node_total_audit_count Node_TotalAuditCount_Field,

6
satellite/satellitedb/dbx/satellitedb.dbx.postgres.sql
View File

@ -102,6 +102,12 @@ CREATE TABLE nodes (
wallet text NOT NULL,
free_bandwidth bigint NOT NULL,
free_disk bigint NOT NULL,
major bigint NOT NULL,
minor bigint NOT NULL,
patch bigint NOT NULL,
hash text NOT NULL,
timestamp timestamp with time zone NOT NULL,
release boolean NOT NULL,
latency_90 bigint NOT NULL,
audit_success_count bigint NOT NULL,
total_audit_count bigint NOT NULL,

6
satellite/satellitedb/dbx/satellitedb.dbx.sqlite3.sql
View File

@ -102,6 +102,12 @@ CREATE TABLE nodes (
wallet TEXT NOT NULL,
free_bandwidth INTEGER NOT NULL,
free_disk INTEGER NOT NULL,
major INTEGER NOT NULL,
minor INTEGER NOT NULL,
patch INTEGER NOT NULL,
hash TEXT NOT NULL,
timestamp TIMESTAMP NOT NULL,
release INTEGER NOT NULL,
latency_90 INTEGER NOT NULL,
audit_success_count INTEGER NOT NULL,
total_audit_count INTEGER NOT NULL,

4
satellite/satellitedb/locked.go
View File

@ -753,10 +753,10 @@ func (m *lockedOverlayCache) Update(ctx context.Context, value *pb.Node) error {
}
// UpdateOperator updates the email and wallet for a given node ID for satellite payments.
func (m *lockedOverlayCache) UpdateOperator(ctx context.Context, node storj.NodeID, updatedOperator pb.NodeOperator) (stats *overlay.NodeDossier, err error) {
func (m *lockedOverlayCache) UpdateNodeInfo(ctx context.Context, node storj.NodeID, nodeInfo *pb.InfoResponse) (stats *overlay.NodeDossier, err error) {
m.Lock()
defer m.Unlock()
return m.db.UpdateOperator(ctx, node, updatedOperator)
return m.db.UpdateNodeInfo(ctx, node, nodeInfo)
}
// UpdateStats all parts of single storagenode's stats.

18
satellite/satellitedb/migrate.go
View File

@ -425,7 +425,7 @@ func (db *DB) PostgresMigration() *migrate.Migration {
PRIMARY KEY ( bucket_id, interval_start )
)`,
`ALTER TABLE bucket_usages DROP CONSTRAINT bucket_usages_rollup_end_time_bucket_id_key`,
`CREATE UNIQUE INDEX bucket_id_rollup_end_time_index ON bucket_usages (
`CREATE UNIQUE INDEX bucket_id_rollup_end_time_index ON bucket_usages (
bucket_id,
rollup_end_time )`,
},
@ -530,6 +530,18 @@ func (db *DB) PostgresMigration() *migrate.Migration {
`ALTER TABLE bucket_bandwidth_rollups ADD CONSTRAINT bucket_bandwidth_rollups_pk PRIMARY KEY (bucket_name, project_id, interval_start, action);`,
},
},
{
Description: "Add new Columns to store version information",
Version: 14,
Action: migrate.SQL{
`ALTER TABLE nodes ADD major bigint NOT NULL DEFAULT 0;
ALTER TABLE nodes ADD minor bigint NOT NULL DEFAULT 1;
ALTER TABLE nodes ADD patch bigint NOT NULL DEFAULT 0;
ALTER TABLE nodes ADD hash TEXT NOT NULL DEFAULT '';
ALTER TABLE nodes ADD timestamp TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT 'epoch';
ALTER TABLE nodes ADD release bool NOT NULL DEFAULT FALSE;`,
},
},
},
}
}
@ -537,7 +549,7 @@ func (db *DB) PostgresMigration() *migrate.Migration {
func postgresHasColumn(tx *sql.Tx, table, column string) (bool, error) {
var columnName string
err := tx.QueryRow(`
SELECT column_name FROM information_schema.COLUMNS
SELECT column_name FROM information_schema.COLUMNS
WHERE table_schema = CURRENT_SCHEMA
AND table_name = $1
AND column_name = $2
@ -555,7 +567,7 @@ func postgresHasColumn(tx *sql.Tx, table, column string) (bool, error) {
func postgresColumnNullability(tx *sql.Tx, table, column string) (bool, error) {
var nullability string
err := tx.QueryRow(`
SELECT is_nullable FROM information_schema.COLUMNS
SELECT is_nullable FROM information_schema.COLUMNS
WHERE table_schema = CURRENT_SCHEMA
AND table_name = $1
AND column_name = $2

123
satellite/satellitedb/overlaycache.go
View File

@ -9,9 +9,11 @@ import (
"strings"
"time"
"github.com/golang/protobuf/ptypes"
"github.com/zeebo/errs"
monkit "gopkg.in/spacemonkeygo/monkit.v2"
"storj.io/storj/internal/version"
"storj.io/storj/pkg/overlay"
"storj.io/storj/pkg/pb"
"storj.io/storj/pkg/storj"
@ -33,31 +35,57 @@ type overlaycache struct {
func (cache *overlaycache) SelectStorageNodes(ctx context.Context, count int, criteria *overlay.NodeCriteria) ([]*pb.Node, error) {
nodeType := int(pb.NodeType_STORAGE)
return cache.queryFilteredNodes(ctx, criteria.Excluded, count, `
safeQuery := `
WHERE type = ? AND free_bandwidth >= ? AND free_disk >= ?
AND total_audit_count >= ?
AND audit_success_ratio >= ?
AND total_uptime_count >= ?
AND uptime_ratio >= ?
AND last_contact_success > ?
AND last_contact_success > last_contact_failure
`, nodeType, criteria.FreeBandwidth, criteria.FreeDisk,
AND last_contact_success > last_contact_failure`
args := append(make([]interface{}, 0, 13),
nodeType, criteria.FreeBandwidth, criteria.FreeDisk,
criteria.AuditCount, criteria.AuditSuccessRatio, criteria.UptimeCount, criteria.UptimeSuccessRatio,
time.Now().Add(-1*time.Hour),
)
time.Now().Add(-overlay.OnlineWindow))
if criteria.MinimumVersion != "" {
v, err := version.NewSemVer(criteria.MinimumVersion)
if err != nil {
return nil, Error.New("invalid node selection criteria version: %v", err)
}
safeQuery += `
AND major > ? OR (major = ? AND (minor > ? OR (minor = ? AND patch >= ?)))
AND release`
args = append(args, v.Major, v.Major, v.Minor, v.Minor, v.Patch)
}
return cache.queryFilteredNodes(ctx, criteria.Excluded, count, safeQuery, args...)
}
func (cache *overlaycache) SelectNewStorageNodes(ctx context.Context, count int, criteria *overlay.NewNodeCriteria) ([]*pb.Node, error) {
nodeType := int(pb.NodeType_STORAGE)
return cache.queryFilteredNodes(ctx, criteria.Excluded, count, `
safeQuery := `
WHERE type = ? AND free_bandwidth >= ? AND free_disk >= ?
AND total_audit_count < ?
AND last_contact_success > ?
AND last_contact_success > last_contact_failure
`, nodeType, criteria.FreeBandwidth, criteria.FreeDisk,
criteria.AuditThreshold,
time.Now().Add(-1*time.Hour),
)
AND last_contact_success > last_contact_failure`
args := append(make([]interface{}, 0, 10),
nodeType, criteria.FreeBandwidth, criteria.FreeDisk, criteria.AuditThreshold, time.Now().Add(-overlay.OnlineWindow))
if criteria.MinimumVersion != "" {
v, err := version.NewSemVer(criteria.MinimumVersion)
if err != nil {
return nil, Error.New("invalid node selection criteria version: %v", err)
}
safeQuery += `
AND major > ? OR (major = ? AND (minor > ? OR (minor = ? AND patch >= ?)))
AND release`
args = append(args, v.Major, v.Major, v.Minor, v.Minor, v.Patch)
}
return cache.queryFilteredNodes(ctx, criteria.Excluded, count, safeQuery, args...)
}
func (cache *overlaycache) queryFilteredNodes(ctx context.Context, excluded []storj.NodeID, count int, safeQuery string, args ...interface{}) (_ []*pb.Node, err error) {
@ -202,7 +230,6 @@ func (cache *overlaycache) Update(ctx context.Context, info *pb.Node) (err error
if err != nil {
return Error.Wrap(err)
}
// TODO: use upsert
_, err = tx.Get_Node_By_Id(ctx, dbx.Node_Id(info.Id.Bytes()))
@ -230,6 +257,22 @@ func (cache *overlaycache) Update(ctx context.Context, info *pb.Node) (err error
reputation = &pb.NodeStats{}
}
ver := info.Version
var semver version.SemVer
var verTime time.Time
if ver == nil {
ver = &pb.NodeVersion{}
} else {
parsed, err := version.NewSemVer(ver.Version)
if err == nil {
semver = *parsed
}
verTime, err = ptypes.Timestamp(ver.Timestamp)
if err != nil {
verTime = time.Time{}
}
}
_, err = tx.Create_Node(
ctx,
dbx.Node_Id(info.Id.Bytes()),
@ -240,6 +283,12 @@ func (cache *overlaycache) Update(ctx context.Context, info *pb.Node) (err error
dbx.Node_Wallet(metadata.Wallet),
dbx.Node_FreeBandwidth(restrictions.FreeBandwidth),
dbx.Node_FreeDisk(restrictions.FreeDisk),
dbx.Node_Major(semver.Major),
dbx.Node_Minor(semver.Minor),
dbx.Node_Patch(semver.Patch),
dbx.Node_Hash(ver.CommitHash),
dbx.Node_Timestamp(verTime),
dbx.Node_Release(ver.Release),
dbx.Node_Latency90(reputation.Latency_90),
dbx.Node_AuditSuccessCount(reputation.AuditSuccessCount),
@ -335,7 +384,6 @@ func (cache *overlaycache) CreateStats(ctx context.Context, nodeID storj.NodeID,
if dbNode == nil {
return nil, Error.Wrap(errs.New("unable to get node by ID: %s", nodeID.String()))
}
return getNodeStats(dbNode), Error.Wrap(tx.Commit())
}
@ -459,13 +507,36 @@ func (cache *overlaycache) UpdateStats(ctx context.Context, updateReq *overlay.U
return getNodeStats(dbNode), Error.Wrap(tx.Commit())
}
// UpdateOperator updates the email and wallet for a given node ID for satellite payments.
func (cache *overlaycache) UpdateOperator(ctx context.Context, nodeID storj.NodeID, operator pb.NodeOperator) (stats *overlay.NodeDossier, err error) {
// UpdateNodeInfo updates the email and wallet for a given node ID for satellite payments.
func (cache *overlaycache) UpdateNodeInfo(ctx context.Context, nodeID storj.NodeID, nodeInfo *pb.InfoResponse) (stats *overlay.NodeDossier, err error) {
defer mon.Task()(&ctx)(&err)
updateFields := dbx.Node_Update_Fields{
Wallet: dbx.Node_Wallet(operator.GetWallet()),
Email: dbx.Node_Email(operator.GetEmail()),
var updateFields dbx.Node_Update_Fields
if nodeInfo != nil {
if nodeInfo.GetOperator() != nil {
updateFields.Wallet = dbx.Node_Wallet(nodeInfo.GetOperator().GetWallet())
updateFields.Email = dbx.Node_Email(nodeInfo.GetOperator().GetEmail())
}
if nodeInfo.GetCapacity() != nil {
updateFields.FreeDisk = dbx.Node_FreeDisk(nodeInfo.GetCapacity().GetFreeDisk())
updateFields.FreeBandwidth = dbx.Node_FreeBandwidth(nodeInfo.GetCapacity().GetFreeBandwidth())
}
if nodeInfo.GetVersion() != nil {
semVer, err := version.NewSemVer(nodeInfo.GetVersion().GetVersion())
if err != nil {
return &overlay.NodeDossier{}, errs.New("unable to convert version to semVer")
}
pbts, err := ptypes.Timestamp(nodeInfo.GetVersion().GetTimestamp())
if err != nil {
return &overlay.NodeDossier{}, errs.New("unable to convert version timestamp")
}
updateFields.Major = dbx.Node_Major(semVer.Major)
updateFields.Minor = dbx.Node_Minor(semVer.Minor)
updateFields.Patch = dbx.Node_Patch(semVer.Patch)
updateFields.Hash = dbx.Node_Hash(nodeInfo.GetVersion().GetCommitHash())
updateFields.Timestamp = dbx.Node_Timestamp(pbts)
updateFields.Release = dbx.Node_Release(nodeInfo.GetVersion().GetRelease())
}
}
updatedDBNode, err := cache.db.Update_Node_By_Id(ctx, dbx.Node_Id(nodeID.Bytes()), updateFields)
@ -534,6 +605,16 @@ func convertDBNode(info *dbx.Node) (*overlay.NodeDossier, error) {
if err != nil {
return nil, err
}
ver := &version.SemVer{
Major: info.Major,
Minor: info.Minor,
Patch: info.Patch,
}
pbts, err := ptypes.TimestampProto(info.Timestamp)
if err != nil {
return nil, err
}
node := &overlay.NodeDossier{
Node: pb.Node{
@ -564,6 +645,12 @@ func convertDBNode(info *dbx.Node) (*overlay.NodeDossier, error) {
LastContactSuccess: info.LastContactSuccess,
LastContactFailure: info.LastContactFailure,
},
Version: pb.NodeVersion{
Version: ver.String(),
CommitHash: info.Hash,
Timestamp: pbts,
Release: info.Release,
},
}
if time.Now().Sub(info.LastContactSuccess) < 1*time.Hour && info.LastContactSuccess.After(info.LastContactFailure) {

235
satellite/satellitedb/testdata/postgres.v14.sql vendored Normal file
View File

@ -0,0 +1,235 @@
-- Copied from the corresponding version of dbx generated schema
CREATE TABLE accounting_raws (
id bigserial NOT NULL,
node_id bytea NOT NULL,
interval_end_time timestamp with time zone NOT NULL,
data_total double precision NOT NULL,
data_type integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE accounting_rollups (
id bigserial NOT NULL,
node_id bytea NOT NULL,
start_time timestamp with time zone NOT NULL,
put_total bigint NOT NULL,
get_total bigint NOT NULL,
get_audit_total bigint NOT NULL,
get_repair_total bigint NOT NULL,
put_repair_total bigint NOT NULL,
at_rest_total double precision NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE accounting_timestamps (
name text NOT NULL,
value timestamp with time zone NOT NULL,
PRIMARY KEY ( name )
);
CREATE TABLE bucket_bandwidth_rollups (
bucket_name bytea NOT NULL,
project_id bytea NOT NULL,
interval_start timestamp NOT NULL,
interval_seconds integer NOT NULL,
action integer NOT NULL,
inline bigint NOT NULL,
allocated bigint NOT NULL,
settled bigint NOT NULL,
PRIMARY KEY ( bucket_name, project_id, interval_start, action )
);
CREATE TABLE bucket_storage_tallies (
bucket_name bytea NOT NULL,
project_id bytea NOT NULL,
interval_start timestamp NOT NULL,
inline bigint NOT NULL,
remote bigint NOT NULL,
remote_segments_count integer NOT NULL,
inline_segments_count integer NOT NULL,
object_count integer NOT NULL,
metadata_size bigint NOT NULL,
PRIMARY KEY ( bucket_name, project_id, interval_start )
);
CREATE TABLE bucket_usages (
id bytea NOT NULL,
bucket_id bytea NOT NULL,
rollup_end_time timestamp with time zone NOT NULL,
remote_stored_data bigint NOT NULL,
inline_stored_data bigint NOT NULL,
remote_segments integer NOT NULL,
inline_segments integer NOT NULL,
objects integer NOT NULL,
metadata_size bigint NOT NULL,
repair_egress bigint NOT NULL,
get_egress bigint NOT NULL,
audit_egress bigint NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE bwagreements (
serialnum text NOT NULL,
storage_node_id bytea NOT NULL,
uplink_id bytea NOT NULL,
action bigint NOT NULL,
total bigint NOT NULL,
created_at timestamp with time zone NOT NULL,
expires_at timestamp with time zone NOT NULL,
PRIMARY KEY ( serialnum )
);
CREATE TABLE certRecords (
publickey bytea NOT NULL,
id bytea NOT NULL,
update_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE injuredsegments (
id bigserial NOT NULL,
info bytea NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE irreparabledbs (
segmentpath bytea NOT NULL,
segmentdetail bytea NOT NULL,
pieces_lost_count bigint NOT NULL,
seg_damaged_unix_sec bigint NOT NULL,
repair_attempt_count bigint NOT NULL,
PRIMARY KEY ( segmentpath )
);
CREATE TABLE nodes (
id bytea NOT NULL,
address text NOT NULL,
protocol integer NOT NULL,
type integer NOT NULL,
email text NOT NULL,
wallet text NOT NULL,
free_bandwidth bigint NOT NULL,
free_disk bigint NOT NULL,
major bigint NOT NULL,
minor bigint NOT NULL,
patch bigint NOT NULL,
hash text NOT NULL,
timestamp timestamp with time zone NOT NULL,
release boolean NOT NULL,
latency_90 bigint NOT NULL,
audit_success_count bigint NOT NULL,
total_audit_count bigint NOT NULL,
audit_success_ratio double precision NOT NULL,
uptime_success_count bigint NOT NULL,
total_uptime_count bigint NOT NULL,
uptime_ratio double precision NOT NULL,
created_at timestamp with time zone NOT NULL,
updated_at timestamp with time zone NOT NULL,
last_contact_success timestamp with time zone NOT NULL,
last_contact_failure timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE projects (
id bytea NOT NULL,
name text NOT NULL,
description text NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE registration_tokens (
secret bytea NOT NULL,
owner_id bytea,
project_limit integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( secret ),
UNIQUE ( owner_id )
);
CREATE TABLE serial_numbers (
id serial NOT NULL,
serial_number bytea NOT NULL,
bucket_id bytea NOT NULL,
expires_at timestamp NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE storagenode_bandwidth_rollups (
storagenode_id bytea NOT NULL,
interval_start timestamp NOT NULL,
interval_seconds integer NOT NULL,
action integer NOT NULL,
allocated bigint NOT NULL,
settled bigint NOT NULL,
PRIMARY KEY ( storagenode_id, interval_start, action )
);
CREATE TABLE storagenode_storage_tallies (
storagenode_id bytea NOT NULL,
interval_start timestamp NOT NULL,
total bigint NOT NULL,
PRIMARY KEY ( storagenode_id, interval_start )
);
CREATE TABLE users (
id bytea NOT NULL,
full_name text NOT NULL,
short_name text,
email text NOT NULL,
password_hash bytea NOT NULL,
status integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE api_keys (
id bytea NOT NULL,
project_id bytea NOT NULL REFERENCES projects( id ) ON DELETE CASCADE,
key bytea NOT NULL,
name text NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id ),
UNIQUE ( key ),
UNIQUE ( name, project_id )
);
CREATE TABLE project_members (
member_id bytea NOT NULL REFERENCES users( id ) ON DELETE CASCADE,
project_id bytea NOT NULL REFERENCES projects( id ) ON DELETE CASCADE,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( member_id, project_id )
);
CREATE TABLE used_serials (
serial_number_id integer NOT NULL REFERENCES serial_numbers( id ) ON DELETE CASCADE,
storage_node_id bytea NOT NULL,
PRIMARY KEY ( serial_number_id, storage_node_id )
);
CREATE INDEX bucket_id_project_id_interval_start_interval_seconds ON bucket_bandwidth_rollups ( bucket_name, project_id, interval_start, interval_seconds );
CREATE UNIQUE INDEX bucket_id_rollup ON bucket_usages ( bucket_id, rollup_end_time );
CREATE UNIQUE INDEX serial_number ON serial_numbers ( serial_number );
CREATE INDEX serial_numbers_expires_at_index ON serial_numbers ( expires_at );
CREATE INDEX storagenode_id_interval_start_interval_seconds ON storagenode_bandwidth_rollups ( storagenode_id, interval_start, interval_seconds );
---
INSERT INTO "accounting_raws" VALUES (1, E'\\3510\\323\\225"~\\036<\\342\\330m\\0253Jhr\\246\\233K\\246#\\2303\\351\\256\\275j\\212UM\\362\\207', '2019-02-14 08:16:57.812849+00', 1000, 0, '2019-02-14 08:16:57.844849+00');
INSERT INTO "accounting_rollups"("id", "node_id", "start_time", "put_total", "get_total", "get_audit_total", "get_repair_total", "put_repair_total", "at_rest_total") VALUES (1, E'\\367M\\177\\251]t/\\022\\256\\214\\265\\025\\224\\204:\\217\\212\\0102<\\321\\374\\020&\\271Qc\\325\\261\\354\\246\\233'::bytea, '2019-02-09 00:00:00+00', 1000, 2000, 3000, 4000, 0, 5000);
INSERT INTO "accounting_timestamps" VALUES ('LastAtRestTally', '0001-01-01 00:00:00+00');
INSERT INTO "accounting_timestamps" VALUES ('LastRollup', '0001-01-01 00:00:00+00');
INSERT INTO "accounting_timestamps" VALUES ('LastBandwidthTally', '0001-01-01 00:00:00+00');
INSERT INTO "nodes"("id", "address", "protocol", "type", "email", "wallet", "free_bandwidth", "free_disk", "major", "minor", "patch", "hash", "timestamp", "release","latency_90", "audit_success_count", "total_audit_count", "audit_success_ratio", "uptime_success_count", "total_uptime_count", "uptime_ratio", "created_at", "updated_at", "last_contact_success", "last_contact_failure") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '127.0.0.1:55518', 0, 4, '', '', -1, -1, 0, 1, 0, '', 'epoch', false, 0, 0, 0, 0, 3, 3, 1, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch');
INSERT INTO "projects"("id", "name", "description", "created_at") VALUES (E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, 'ProjectName', 'projects description', '2019-02-14 08:28:24.254934+00');
INSERT INTO "api_keys"("id", "project_id", "key", "name", "created_at") VALUES (E'\\334/\\302;\\225\\355O\\323\\276f\\247\\354/6\\241\\033'::bytea, E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'\\000]\\326N \\343\\270L\\327\\027\\337\\242\\240\\322mOl\\0318\\251.P I'::bytea, 'key 2', '2019-02-14 08:28:24.267934+00');
INSERT INTO "users"("id", "full_name", "short_name", "email", "password_hash", "status", "created_at") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 'Noahson', 'William', '1email1@ukr.net', E'some_readable_hash'::bytea, 1, '2019-02-14 08:28:24.614594+00');
INSERT INTO "projects"("id", "name", "description", "created_at") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, 'projName1', 'Test project 1', '2019-02-14 08:28:24.636949+00');
INSERT INTO "project_members"("member_id", "project_id", "created_at") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, '2019-02-14 08:28:24.677953+00');
INSERT INTO "bwagreements"("serialnum", "storage_node_id", "action", "total", "created_at", "expires_at", "uplink_id") VALUES ('8fc0ceaa-984c-4d52-bcf4-b5429e1e35e812FpiifDbcJkePa12jxjDEutKrfLmwzT7sz2jfVwpYqgtM8B74c', E'\\245Z[/\\333\\022\\011\\001\\036\\003\\204\\005\\032.\\206\\333E\\261\\342\\227=y,}aRaH6\\240\\370\\000'::bytea, 1, 666, '2019-02-14 15:09:54.420181+00', '2019-02-14 16:09:54+00', E'\\253Z+\\374eFm\\245$\\036\\206\\335\\247\\263\\350x\\\\\\304+\\364\\343\\364+\\276fIJQ\\361\\014\\232\\000'::bytea);
INSERT INTO "irreparabledbs" ("segmentpath", "segmentdetail", "pieces_lost_count", "seg_damaged_unix_sec", "repair_attempt_count") VALUES ('\x49616d5365676d656e746b6579696e666f30', '\x49616d5365676d656e7464657461696c696e666f30', 10, 1550159554, 10);
INSERT INTO "injuredsegments" ("id", "info") VALUES (1, '\x0a0130120100');
INSERT INTO "certrecords" VALUES (E'0Y0\\023\\006\\007*\\206H\\316=\\002\\001\\006\\010*\\206H\\316=\\003\\001\\007\\003B\\000\\004\\360\\267\\227\\377\\253u\\222\\337Y\\324C:GQ\\010\\277v\\010\\315D\\271\\333\\337.\\203\\023=C\\343\\014T%6\\027\\362?\\214\\326\\017U\\334\\000\\260\\224\\260J\\221\\304\\331F\\304\\221\\236zF,\\325\\326l\\215\\306\\365\\200\\022', E'L\\301|\\200\\247}F|1\\320\\232\\037n\\335\\241\\206\\244\\242\\207\\204.\\253\\357\\326\\352\\033Dt\\202`\\022\\325', '2019-02-14 08:07:31.335028+00');
INSERT INTO "bucket_usages" ("id", "bucket_id", "rollup_end_time", "remote_stored_data", "inline_stored_data", "remote_segments", "inline_segments", "objects", "metadata_size", "repair_egress", "get_egress", "audit_egress") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001",'::bytea, E'\\366\\146\\032\\321\\316\\161\\070\\133\\302\\271",'::bytea, '2019-03-06 08:28:24.677953+00', 10, 11, 12, 13, 14, 15, 16, 17, 18);
INSERT INTO "registration_tokens" ("secret", "owner_id", "project_limit", "created_at") VALUES (E'\\070\\127\\144\\013\\332\\344\\102\\376\\306\\056\\303\\130\\106\\132\\321\\276\\321\\274\\170\\264\\054\\333\\221\\116\\154\\221\\335\\070\\220\\146\\344\\216'::bytea, null, 1, '2019-02-14 08:28:24.677953+00');
INSERT INTO "serial_numbers" ("id", "serial_number", "bucket_id", "expires_at") VALUES (1, E'0123456701234567'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014/testbucket'::bytea, '2019-03-06 08:28:24.677953+00');
INSERT INTO "used_serials" ("serial_number_id", "storage_node_id") VALUES (1, E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n');
INSERT INTO "storagenode_bandwidth_rollups" ("storagenode_id", "interval_start", "interval_seconds", "action", "allocated", "settled") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '2019-03-06 08:00:00.000000+00', 3600, 1, 1024, 2024);
INSERT INTO "storagenode_storage_tallies" ("storagenode_id", "interval_start", "total") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '2019-03-06 08:00:00.000000+00', 4024);
INSERT INTO "bucket_bandwidth_rollups" ("bucket_name", "project_id", "interval_start", "interval_seconds", "action", "inline", "allocated", "settled") VALUES (E'testbucket'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea,'2019-03-06 08:00:00.000000+00', 3600, 1, 1024, 2024, 3024);
INSERT INTO "bucket_storage_tallies" ("bucket_name", "project_id", "interval_start", "inline", "remote", "remote_segments_count", "inline_segments_count", "object_count", "metadata_size") VALUES (E'testbucket'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea,'2019-03-06 08:00:00.000000+00', 4024, 5024, 0, 0, 0, 0);
-- NEW DATA --

0
scripts/release.sh Executable file → Normal file
View File

6
storagenode/peer.go
View File

@ -148,6 +148,11 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB, config Config, ver
config.ExternalAddress = peer.Addr()
}
pbVersion, err := versionInfo.Proto()
if err != nil {
return nil, errs.Combine(err, peer.Close())
}
self := pb.Node{
Id: peer.ID(),
Type: pb.NodeType_STORAGE,
@ -158,6 +163,7 @@ func New(log *zap.Logger, full *identity.FullIdentity, db DB, config Config, ver
Metadata: &pb.NodeMetadata{
Wallet: config.Operator.Wallet,
},
Version: pbVersion,
}
kdb, ndb := peer.DB.RoutingTable()