frostfs-api/netmap/types.proto

syntax = "proto3";

package neo.fs.v2.netmap;

option go_package = "github.com/nspcc-dev/neofs-api-go/v2/netmap/grpc;netmap";
option csharp_namespace = "Neo.FileStorage.API.Netmap";

import "refs/types.proto";

// Operations on filters
enum Operation {
  // No Operation defined
  OPERATION_UNSPECIFIED = 0;

  // Equal
  EQ = 1;

  // Not Equal
  NE = 2;

  // Greater then
  GT = 3;

  // Greater or equal
  GE = 4;

  // Less then
  LT = 5;

  // Less or equal
  LE = 6;

  // Logical OR
  OR = 7;

  // Logical AND
  AND = 8;
}

// Selector modifier shows how the node set will be formed. By default selector
// just groups nodes into a bucket by attribute, selecting nodes only by their
// hash distance.
enum Clause {
  // No modifier defined. Nodes will be selected from the bucket randomly
  CLAUSE_UNSPECIFIED = 0;

  // SAME will select only nodes having the same value of bucket attribute
  SAME = 1;

  // DISTINCT will select nodes having different values of bucket attribute
  DISTINCT = 2;
}

// This filter will return the subset of nodes from `NetworkMap` or another filter's
// results that will satisfy filter's conditions.
message Filter {
  // Name of the filter or a reference to a named filter. '*' means
  // application to the whole unfiltered NetworkMap. At top level it's used as a
  // filter name. At lower levels it's considered to be a reference to another
  // named filter
  string name = 1 [json_name = "name"];

  // Key to filter
  string key = 2 [json_name = "key"];

  // Filtering operation
  Operation op = 3 [json_name = "op"];

  // Value to match
  string value = 4 [json_name = "value"];

  // List of inner filters. Top level operation will be applied to the whole
  // list.
  repeated Filter filters = 5 [json_name = "filters"];
}

// Selector chooses a number of nodes from the bucket taking the nearest nodes
// to the provided `ContainerID` by hash distance.
message Selector {
  // Selector name to reference in object placement section
  string name = 1 [json_name = "name"];

  // How many nodes to select from the bucket
  uint32 count = 2 [json_name = "count"];

  // Selector modifier showing how to form a bucket
  Clause clause = 3 [json_name = "clause"];

  // Bucket attribute to select from
  string attribute = 4 [json_name = "attribute"];

  // Filter reference to select from
  string filter = 5 [json_name = "filter"];
}

// Number of object replicas in a set of nodes from the defined selector. If no
// selector set, the root bucket containing all possible nodes will be used by
// default.
message Replica {
  // How many object replicas to put
  uint32 count = 1 [json_name = "count"];

  // Named selector bucket to put replicas
  string selector = 2 [json_name = "selector"];
}

// Set of rules to select a subset of nodes from `NetworkMap` able to store
// container's objects. The format is simple enough to transpile from different
// storage policy definition languages.
message PlacementPolicy {
  // Rules to set number of object replicas and place each one into a named
  // bucket
  repeated Replica replicas = 1 [json_name = "replicas"];

  // Container backup factor controls how deep NeoFS will search for nodes
  // alternatives to include into container's nodes subset
  uint32 container_backup_factor = 2 [json_name = "containerBackupFactor"];

  // Set of Selectors to form the container's nodes subset
  repeated Selector selectors = 3 [json_name = "selectors"];

  // List of named filters to reference in selectors
  repeated Filter filters = 4 [json_name = "filters"];

  // Subnetwork ID to select nodes from. Zero subnet (default) represents
  // all of the nodes which didn't explicitly opt out of membership.
  refs.SubnetID subnet_id = 5 [json_name = "subnetId"];
}

// NeoFS node description
message NodeInfo {
  // Public key of the NeoFS node in a binary format
  bytes public_key = 1 [json_name = "publicKey"];

  // Ways to connect to a node
  repeated string addresses = 2 [json_name = "addresses"];

  // Administrator-defined Attributes of the NeoFS Storage Node.
  //
  // `Attribute` is a Key-Value metadata pair. Key name must be a valid UTF-8
  // string. Value can't be empty.
  //
  // Attributes can be constructed into a chain of attributes: any attribute can
  // have a parent attribute and a child attribute (except the first and the last
  // one). A string representation of the chain of attributes in NeoFS Storage
  // Node configuration uses ":" and "/" symbols, e.g.:
  //
  //        `NEOFS_NODE_ATTRIBUTE_1=key1:val1/key2:val2`
  //
  // Therefore the string attribute representation in the Node configuration must
  // use "\:", "\/" and "\\" escaped symbols if any of them appears in an attribute's
  // key or value.
  //
  // Node's attributes are mostly used during Storage Policy evaluation to
  // calculate object's placement and find a set of nodes satisfying policy
  // requirements. There are some "well-known" node attributes common to all the
  // Storage Nodes in the network and used implicitly with default values if not
  // explicitly set:
  //
  // * Capacity \
  //   Total available disk space in Gigabytes.
  // * Price \
  //   Price in GAS tokens for storing one GB of data during one Epoch. In node
  //   attributes it's a string presenting floating point number with comma or
  //   point delimiter for decimal part. In the Network Map it will be saved as
  //   64-bit unsigned integer representing number of minimal token fractions.
  // * __NEOFS__SUBNET_%s \
  //   `True` or `False`. Defines if the node is included in the `%s` subnetwork
  //   or not. `%s` must be an existing subnetwork's ID (non-negative integer number).
  //   A node can be included in more than one subnetwork and, therefore, can contain
  //   more than one subnet attribute. A missing attribute is equivalent to the
  //   presence of the attribute with `False` value (except default zero subnetwork
  //   (with `%s` == 0) for which missing attribute means inclusion in that network).
  // * UN-LOCODE \
  //   Node's geographic location in
  //   [UN/LOCODE](https://www.unece.org/cefact/codesfortrade/codes_index.html)
  //   format approximated to the nearest point defined in the standard.
  // * CountryCode \
  //   Country code in
  //   [ISO 3166-1_alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)
  //   format. Calculated automatically from `UN-LOCODE` attribute.
  // * Country \
  //   Country short name in English, as defined in
  //   [ISO-3166](https://www.iso.org/obp/ui/#search). Calculated automatically
  //   from `UN-LOCODE` attribute.
  // * Location \
  //   Place names are given, whenever possible, in their national language
  //   versions as expressed in the Roman alphabet using the 26 characters of
  //   the character set adopted for international trade data interchange,
  //   written without diacritics . Calculated automatically from `UN-LOCODE`
  //   attribute.
  // * SubDivCode \
  //   Country's administrative subdivision where node is located. Calculated
  //   automatically from `UN-LOCODE` attribute based on `SubDiv` field.
  //   Presented in [ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2)
  //   format.
  // * SubDiv \
  //   Country's administrative subdivision name, as defined in
  //   [ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2). Calculated
  //   automatically from `UN-LOCODE` attribute.
  // * Continent \
  //   Node's continent name according to the [Seven-Continent model]
  //   (https://en.wikipedia.org/wiki/Continent#Number). Calculated
  //   automatically from `UN-LOCODE` attribute.
  //
  // For detailed description of each well-known attribute please see the
  // corresponding section in NeoFS Technical Specification.
  message Attribute {
    // Key of the node attribute
    string key = 1 [json_name = "key"];

    // Value of the node attribute
    string value = 2 [json_name = "value"];

    // Parent keys, if any. For example for `City` it could be `Region` and
    // `Country`.
    repeated string parents = 3 [json_name = "parents"];
  }
  // Carries list of the NeoFS node attributes in a key-value form. Key name
  // must be a node-unique valid UTF-8 string. Value can't be empty. NodeInfo
  // structures with duplicated attribute names or attributes with empty values
  // will be considered invalid.
  repeated Attribute attributes = 3 [json_name = "attributes"];

  // Represents the enumeration of various states of the NeoFS node.
  enum State {
    // Unknown state
    UNSPECIFIED = 0;

    // Active state in the network
    ONLINE = 1;

    // Network unavailable state
    OFFLINE = 2;

    // Maintenance state
    MAINTENANCE = 3;
  }

  // Carries state of the NeoFS node
  State state = 4 [json_name = "state"];
}

// Network map structure
message Netmap {
    // Network map revision number.
    uint64 epoch = 1 [json_name = "epoch"];

    // Nodes presented in network.
    repeated NodeInfo nodes = 2 [json_name = "nodes"];
}

// NeoFS network configuration
message NetworkConfig {
  // Single configuration parameter
  message Parameter {
    // Parameter key. UTF-8 encoded string
    bytes key = 1 [json_name = "key"];

    // Parameter value
    bytes value = 2 [json_name = "value"];
  }
  // List of parameter values
  repeated Parameter parameters = 1 [json_name = "parameters"];
}

// Information about NeoFS network
message NetworkInfo {
    // Number of the current epoch in the NeoFS network
    uint64 current_epoch = 1 [json_name = "currentEpoch"];

    // Magic number of the sidechain of the NeoFS network
    uint64 magic_number = 2 [json_name = "magicNumber"];

    // MillisecondsPerBlock network parameter of the sidechain of the NeoFS network
    int64 ms_per_block = 3 [json_name = "msPerBlock"];

    // NeoFS network configuration
    NetworkConfig network_config = 4 [json_name = "networkConfig"];
}