storj/pkg/pb/inspector.proto

// Copyright (C) 2019 Storj Labs, Inc.
// See LICENSE for copying information.

syntax = "proto3";
option go_package = "pb";

import "gogo.proto";
import "node.proto";
import "pointerdb.proto";
import "google/protobuf/duration.proto";
import "google/protobuf/timestamp.proto";

package inspector;

service KadInspector {
  // CountNodes returns the number of nodes in the routing table
  rpc CountNodes(CountNodesRequest) returns (CountNodesResponse);
  // PingNode sends a PING RPC to a node and returns its availability
  rpc PingNode(PingNodeRequest) returns (PingNodeResponse);
  // LookupNode triggers a Kademlia FindNode and returns the response
  rpc LookupNode(LookupNodeRequest) returns (LookupNodeResponse);
  // NodeInfo sends a PING RPC to a node and returns its local info
  rpc NodeInfo(NodeInfoRequest) returns (NodeInfoResponse);
  // FindNear returns limit number of IDs "near" the Start ID
  rpc FindNear(FindNearRequest) returns (FindNearResponse);
  // DumpNodes returns all the nodes in the node database
  rpc DumpNodes(DumpNodesRequest) returns (DumpNodesResponse);
  // GetBucketList returns all the buckets with all their nodes
  rpc GetBucketList(GetBucketListRequest) returns (GetBucketListResponse);
}

service OverlayInspector {
  // CountNodes returns the number of nodes in the cache
  rpc CountNodes(CountNodesRequest) returns (CountNodesResponse);
  // DumpNodes returns all the nodes in the cache
  rpc DumpNodes(DumpNodesRequest) returns (DumpNodesResponse);
}

service PieceStoreInspector {
  // Stats return space and bandwidth stats for a storagenode
  rpc Stats(StatsRequest) returns (StatSummaryResponse) {}
  // Dashboard returns stats for a specific storagenode
  rpc Dashboard(DashboardRequest) returns (DashboardResponse) {}
}

service IrreparableInspector {
  // ListIrreparableSegments returns damaged segments
  rpc ListIrreparableSegments(ListIrreparableSegmentsRequest) returns (ListIrreparableSegmentsResponse);
}

service HealthInspector {
  // ObjectHealth will return stats about the health of an object
  rpc ObjectHealth(ObjectHealthRequest) returns (ObjectHealthResponse) {}
  // SegmentHealth will return stats about the health of a segment
  rpc SegmentHealth(SegmentHealthRequest) returns (SegmentHealthResponse) {}
}


// ListSegments
message ListIrreparableSegmentsRequest {
  int32 limit = 1;
  int32 offset = 2;
}

message IrreparableSegment {
  bytes path = 1;
  pointerdb.Pointer segment_detail = 2;
  int32 lost_pieces = 3;
  int64 last_repair_attempt = 4;
  int64 repair_attempt_count = 5;
}

message ListIrreparableSegmentsResponse {
  repeated IrreparableSegment segments = 1;
}

// CountNodes
message CountNodesResponse {
  int64 count = 1;
}

message CountNodesRequest {
}

message GetBucketListRequest {
}

message GetBucketListResponse {
	message Bucket {
	  bytes bucket_id = 1 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
	  repeated node.Node routing_nodes = 2;
	  repeated node.Node cached_nodes = 3;
	}
	repeated Bucket buckets = 1;
}

// GetBuckets
message GetBucketsRequest {
}

message GetBucketsResponse {
  int64 total = 1;
  repeated bytes ids = 2 [(gogoproto.customtype) = "NodeID"];
}

// GetBucket
message GetBucketRequest {
  bytes id = 1 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
}

message GetBucketResponse {
  bytes id = 1 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
  repeated node.Node nodes = 2;
}

message Bucket {
  repeated node.Node nodes = 2;
}

message BucketList {
  repeated node.Node nodes = 1;
}
// PingNode
message PingNodeRequest {
  bytes id = 1 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
  string address = 2;
}

message PingNodeResponse {
  bool ok = 1;
}

message LookupNodeRequest {
  string id = 1;
  string address = 2;
}

message LookupNodeResponse {
  node.Node node = 1;
  node.NodeMetadata meta = 2;
}

message NodeInfoRequest {
  bytes id = 1 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
  node.NodeAddress address = 2;
}

message NodeInfoResponse {
  node.NodeType type = 1;
  node.NodeOperator operator = 2;
  node.NodeCapacity capacity = 3;
  node.NodeVersion version = 4;
}

message FindNearRequest {
  bytes id = 1 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
  bytes start = 2 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
  int64 limit = 3;
}

message FindNearResponse {
  repeated node.Node nodes = 2;
}

message DumpNodesRequest {}

message DumpNodesResponse {
  repeated node.Node nodes = 1;
}
message StatsRequest {
}

message StatSummaryResponse {
  int64 used_space = 1;
  int64 available_space = 2;
  int64 used_ingress = 3;
  int64 used_egress = 4;
  int64 used_bandwidth = 5;
  int64 available_bandwidth = 6;
}

message DashboardRequest {
}

message DashboardResponse {
  bytes node_id = 1 [(gogoproto.customtype) = "NodeID", (gogoproto.nullable) = false];
  int64 node_connections = 2;
  string bootstrap_address = 3;
  string internal_address = 4;
  string external_address = 5;
  StatSummaryResponse stats = 6;
  google.protobuf.Duration uptime = 7;
  google.protobuf.Timestamp last_pinged = 8;
  google.protobuf.Timestamp last_queried = 9;
}

message SegmentHealthRequest {
  bytes bucket = 1;         // segment bucket name
  bytes encrypted_path = 2; // segment encrypted path
  int64 segment_index = 3;  // segment index
  bytes project_id = 4;     // segment project id
}

message SegmentHealth {
  repeated bytes healthy_ids = 1 [(gogoproto.customtype) = "NodeID"];   // online + not disqualified
  repeated bytes unhealthy_ids = 2 [(gogoproto.customtype) = "NodeID"]; // online + disqualified
  repeated bytes offline_ids = 3 [(gogoproto.customtype) = "NodeID"];   // offline
  bytes segment = 4;                                                    // path formatted segment index
}

message SegmentHealthResponse {
  SegmentHealth health = 1;                  // Information about a segment's health
  pointerdb.RedundancyScheme redundancy = 2; // expected segment info
}

message ObjectHealthRequest {
  bytes encrypted_path = 1;                  // object encrypted path
  bytes bucket = 2;                          // object bucket name
  bytes project_id = 3;                      // object project id
  int64 start_after_segment = 4;             // Get all segments after specified segment index 
  int64 end_before_segment = 5;              // Stop at segment before specified segment index 
  int32 limit = 6;                           // Max number of segments that are checked
}

message ObjectHealthResponse {
  repeated SegmentHealth segments = 1;       // actual segment info 
  pointerdb.RedundancyScheme redundancy = 2; // expected segment info
}