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 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;
  bytes last_seen_segment_path = 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 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 [deprecated=true];
  string internal_address = 4;
  string external_address = 5;
  string dashboard_address = 6;
  StatSummaryResponse stats = 7;
  google.protobuf.Duration uptime = 8;
  google.protobuf.Timestamp last_pinged = 9 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
  google.protobuf.Timestamp last_queried = 10 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
  bytes last_ping_from_id = 11 [(gogoproto.customtype) = "NodeID"];
  string last_ping_from_address = 12;
}

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
}