path: root/ydb/core/protos/blobstorage_config.proto

syntax = "proto3";

import "ydb/core/protos/blobstorage_disk.proto";
import "ydb/core/protos/blobstorage_disk_color.proto";
import "ydb/core/protos/blobstorage_pdisk_config.proto";
import "library/cpp/actors/protos/interconnect.proto";

package NKikimrBlobStorage;

// Enum defining PDisk underlying drive type (rotational or solid state)
enum EPDiskType {
    ROT = 0; // rotational drives (HDD)
    SSD = 1; // solid state drives (SSD)
    NVME = 2; // PCIe-connected solid state drives (NVMe SSD)
    UNKNOWN_TYPE = 3; // used if device type is unknown or if group consists of different PDisk device types
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// TYPICAL HOST CONFIGURATIONS
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Single drive descriptor of typical host configuration structure
message THostConfigDrive {
    string Path = 1; // path to the device on the host node
    EPDiskType Type = 2; // drive type (rotational or solid state)
    bool SharedWithOs = 3; // is this drive shared with OS in any way? (i.e. has OS partitions)
    bool ReadCentric = 4; // is this drive read-centric?
    uint64 Kind = 5; // nontransparent user-defined kind used for filtering when picking up groups

    // optional PDisk config for these drives; if not set, default configuration is applied; overrides host-wide default
    NKikimrBlobStorage.TPDiskConfig PDiskConfig = 6;
}

// Command used to define typical host configuration. It it used while defining new typical host configurations and as
// a returned structure when reading them.
message TDefineHostConfig {
    uint64 HostConfigId = 1; // unique (to BS_CONTROLLER tablet) host configuration integer id (key)
    string Name = 2; // user-friendly name of typical configuration
    repeated THostConfigDrive Drive = 3; // a full set of drives on every host

    // host-wide default configuration for every PDisk
    NKikimrBlobStorage.TPDiskConfig DefaultHostPDiskConfig = 4;

    // item's generation to prevent concurrent modification
    uint64 ItemConfigGeneration = 100;
}

// Command issued to read specific (or all) host configurations associated with the BS_CONTROLLER tablet.
message TReadHostConfig {
    repeated uint64 HostConfigId = 1; // if empty, then all host configuration entries are returned
}

// Command used to delete typical host configuration identified by its key.
message TDeleteHostConfig {
    uint64 HostConfigId = 1;

    // item's generation to prevent concurrent modification
    uint64 ItemConfigGeneration = 100;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// HOSTS
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Host key structure defines node by providing its FQDN and Interconnect port. There must be unique mapping from
// FQDN:port to NodeId.
message THostKey {
    string Fqdn = 1; // fully qualified domain name of the host
    int32 IcPort = 2; // interconnect port to use
    uint32 NodeId = 3; // may be set instead of Fqdn/IcPort to specify explicit NodeId
}

// Definition of a host entry containing its key (which provides NodeId) and reference to typical host configuration
// that must exist.
message THost {
    THostKey Key = 1; // unique host key defining its location
    uint64 HostConfigId = 2; // reference to typical host configuration table
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// BOXES
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

message TDefineBox {
    uint64 BoxId = 1;
    string Name = 2;
    repeated bytes UserId = 3;
    repeated THost Host = 4;

    // item's generation to prevent concurrent modification
    uint64 ItemConfigGeneration = 100;
}

message TReadBox {
    repeated uint64 BoxId = 1; // if empty, then all box entries are returned
}

message TDeleteBox {
    uint64 BoxId = 1;

    // item's generation to prevent concurrent modification
    uint64 ItemConfigGeneration = 100;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// STORAGE POOLS
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

message TGroupGeometry {
    uint32 RealmLevelBegin = 1;
    uint32 RealmLevelEnd = 2;
    uint32 DomainLevelBegin = 3;
    uint32 DomainLevelEnd = 4;
    uint32 NumFailRealms = 5;
    uint32 NumFailDomainsPerFailRealm = 6;
    uint32 NumVDisksPerFailDomain = 7;
}

message TGroupUsagePattern {
    uint64 SpaceBytes = 1;
    uint64 WriteIOPS = 2;
    uint64 WriteBytesPerSecond = 3;
    uint64 ReadIOPS = 4;
    uint64 ReadBytesPerSecond = 5;
    uint64 InMemCacheBytes = 6;
}

message TPDiskFilter {
    message TRequiredProperty {
        oneof Property {
            EPDiskType Type = 1; // require certain drive type
            bool SharedWithOs = 2; // require certain SharedWithOs property
            bool ReadCentric = 3; // require certain ReadCentric property
            uint64 Kind = 4; // require certain kind
        }
    }
    repeated TRequiredProperty Property = 1; // conjunction of required properties; the same properties must not repeat
}

message TDefineStoragePool {
    message TExistingGroups {
        repeated uint32 GroupId = 1;
    }

    uint64 BoxId = 1; // the box in which we are creating this storage pool
    uint64 StoragePoolId = 2; // integer key unique to the box; if set to zero, Name is used for lookup
    string Name = 3; // user-friendly name
    string ErasureSpecies = 4; // name for erasure species of contained groups
    TGroupGeometry Geometry = 5; // group geometry defining
    string VDiskKind = 6; // kind of created VDisks/VSlots [TVDiskKind.EVDiskKind textual repr]
    TGroupUsagePattern UsagePattern = 7; // how this storage pool is going to be used
    string Kind = 8; // kind of storage pool (user-defined)
    uint32 NumGroups = 9; // explicit number of groups to create
    repeated bytes UserId = 10; // allowed users
    repeated TPDiskFilter PDiskFilter = 11; // matching PDisks
    TExistingGroups ExistingGroups = 12; // existing groups (used while migrating from old-style configuration)
    NActorsInterconnect.TScopeId ScopeId = 13; // scope id for the pool clients
    bool RandomizeGroupMapping = 14; // minimize correlation of groups and drives
    repeated uint64 ExpectedGroupSlotSize = 15; // primarily for debugging purposes; expected slot size for group allocation

    // item's generation to prevent concurrent modification
    uint64 ItemConfigGeneration = 100;

    // encryption mode: 0 for none, 1 for the current mode (chacha8)
    uint32 EncryptionMode = 101;
}

message TReadStoragePool {
    uint64 BoxId = 1; // use Max<ui64> to query all the pools

    // calculates intersection of names and ids
    repeated uint64 StoragePoolId = 2; // when empty, then query all the boxes
    repeated string Name = 3; // when empty, then query all the boxes
}

message TDeleteStoragePool {
    uint64 BoxId = 1;
    uint64 StoragePoolId = 2;

    // item's generation to prevent concurrent modification
    uint64 ItemConfigGeneration = 100;
}

enum EDriveStatus {
    UNKNOWN = 0; // value of status is unknown (default)
    ACTIVE = 1; // working as expected
    INACTIVE = 2; // new groups are not created over this drive, but existing ones continue to work as expected
    BROKEN = 3; // drive is not working, groups are automatically moved out of this drive upon reception of this status
    SPARE = 4; // spare drive -- groups are created only when being moved from BROKEN drives
    FAULTY = 5; // drive is expected to become BROKEN soon, new groups are not created, old groups are asynchronously moved out from this drive
    TO_BE_REMOVED = 6; // same as INACTIVE, but drive is counted in fault model as not working
}

message TGroupStatus {
    enum E {
        UNKNOWN = 0; // group status is unknown (default value)
        FULL = 1; // all VDisks of the group are READY for specific period of time
        PARTIAL = 2; // some of VDisks are operational, but group is not yet DEGRADED
        DEGRADED = 3; // group is DEGRADED -- one random failure may lead to group loss (but may not lead too)
        DISINTEGRATED = 4; // group is not available for operation
    }
}

message TDriveLifeStage {
    enum E {
        UNKNOWN = 0; // life stage is unknown (default)
        NOT_SEEN = 1; // info about drive is located in BSC db, but drive is not seen in any node
        ALLOCATED = 2; // PDisk is created
        REMOVED = 3; // drive marked as removed
        ERROR = 4; // drive was moved between nodes with allocated VDisks
    }
}

message TSerialManagementStage {
    enum E {
        DISCOVER_SERIAL = 0;
        CHECK_SERIAL = 1;
        ONLY_SERIAL = 2;
    }
}

message TUpdateDriveStatus {
    THostKey HostKey = 1; // host on which we are looking for the drive
    string Path = 2; // absolute path to the device as enlisted in PDisk configuration
    EDriveStatus Status = 3; // new status
    uint32 PDiskId = 4; // may be set instead of path to identify PDisk
    string Serial = 5; // may be set instead of path and PDiskId to identify PDisk
    uint64 StatusChangeTimestamp = 6; // used only in return of ReadDriveStatus
}

message TReadDriveStatus {
    THostKey HostKey = 1; // host to query; if not set, then query all hosts
    string Path = 2; // path on the host; if empty, then query all drives on specified hosts (or on all hosts)
}

message TProposeStoragePools {
}

message TQueryBaseConfig {
}

message TPDiskId {
    uint32 NodeId = 1;
    uint32 PDiskId = 2;
}

message TReassignGroupDisk {
    uint32 GroupId = 1;
    uint32 GroupGeneration = 2;
    uint32 FailRealmIdx = 3;
    uint32 FailDomainIdx = 4;
    uint32 VDiskIdx = 5;
    TPDiskId TargetPDiskId = 6; // optional; when not specified, selected automatically
    bool SuppressDonorMode = 7; // when set, donor mode is not used even if it is enabled through BSC
}

enum EClusterFitAlgorithm {
    QUADRATIC = 0;
    HUNGARIAN = 1;
    ANNEALING = 2;
}

message TClusterFit {
    EClusterFitAlgorithm Algorithm = 1;
    uint64 Iterations = 2;
}

message TVSlotMetric {
    NKikimrBlobStorage.TVSlotId VSlotId = 1;
    uint64 Metric = 2;
}

message TClusterFitConfig {
    TBaseConfig BaseConfig = 1;
    repeated TDefineStoragePool StoragePool = 2;
    repeated TVSlotMetric Metric = 3;
    TClusterFit Request = 4;
}

message TMergeBoxes {
    message TStoragePoolIdMap {
        uint64 OriginStoragePoolId = 1;
        uint64 TargetStoragePoolId = 2;
    }

    uint64 OriginBoxId = 1;
    uint64 OriginBoxGeneration = 2;
    uint64 TargetBoxId = 3;
    uint64 TargetBoxGeneration = 4;
    repeated TStoragePoolIdMap StoragePoolIdMap = 5;
}

message TMoveGroups {
    uint64 BoxId = 1;
    uint64 OriginStoragePoolId = 2;
    uint64 OriginStoragePoolGeneration = 3;
    uint64 TargetStoragePoolId = 4;
    uint64 TargetStoragePoolGeneration = 5;
    repeated uint32 ExplicitGroupId = 6; // if no groups are provided, then all groups of origin storage pool are moved
}

message TAddMigrationPlan {
    string Name = 1;
    repeated TMoveCommand MoveCommand = 2;
}

message TDeleteMigrationPlan {
    string Name = 1;
}

message TEnableSelfHeal {
    bool Enable = 1;
}

message TEnableDonorMode {
    bool Enable = 1;
}

message TDeclareIntent {
    // intent is a generic description of an action going to be taken regarding to specific drive (BSC operating unit
    // is a drive, yes); when a whole node is going to be formatted/replaced/offline, one should enumerate all drives
    // of a specific node with the same Kind/BeginTimestamp/EndTimestamp/Action fields

    // in reponse to DeclareIntent command BSC sends response with TDeclareIntent Intent with copied QUERY PART and
    // filled in RESOLUTION; when kind is provided as STATEMENT, resolution is always 'approved'

    enum EKind {
        REQUEST = 0; // action is requested to be taken and may be either approved or not
        STATEMENT = 1; // action is going to be taken (or already taken) and this is just a notification
    }
    enum EDriveAction {
        REPLACE = 0; // drive is going to be replaced (or smth else with data loss); it is expected to become online
                     // and empty just after EndTimestamp
        OFFLINE = 1; // drive is going to be offline, but data will be preserved; it is expected to go offline since
                     // BeginTimestamp and return back online till EndTimestamp
    }
    enum EImpact {
        GROUP_OFFLINE = 0; // group will be offline (i.e. unavaiable for operation)
        GROUP_DATA_LOSS = 1; // group will most probably unrecoverably lose its data
        GROUP_FRAGILE = 2; // group will reach state when one fail may lead to offline or data loss, depending on its nature
    }
    message TAffectedGroup {
        uint32 GroupId = 1;
        EImpact Impact = 2;
    }
    message TDenyReason {
        // the reason for intent query denial; when set, then the query is denied; when cleared, then the query is approved
        string Message = 1; // textual description of denial reason
        repeated TAffectedGroup AffectedGroups = 2; // a set of degraded groups
    }
    message TIntent {
        // QUERY PART
        string UniqueId = 1; // filled in by sender; should not repeat; when matches other one, the intent is not
                             // replaced, but the whole command terminates with an error
        EKind Kind = 2; // kind of the intent
        uint64 BeginTimestamp = 3; // microseconds since Epoch
        uint64 EndTimestamp = 4; // the same unit
        EDriveAction Action = 5; // action to be taken with the device

        // DRIVE PART
        THostKey HostKey = 6; // the host containing the requested drive
        // mutually exclusive fields at input -- exactly one of them MUST be provided; on output, all fields are set
        string Path = 7; // path to the drive (if empty, then considered not set)
        uint32 PDiskId = 8; // pdisk id (if nonzero, otherwise considered not set)
        string DriveSerNo = 9; // drive serial number (if empty, then considered not set)

        // RESOLUTION; when returned from the ReadIntent method, these fields are not set
        TDenyReason DenyReason = 100; // when not set, the query is approved, otherwise describes the reason of denial
        // it is necessary to mention that if even one intent from DeclareIntent command is denied, then the whole
        // command fails
    }
    repeated TIntent Intents = 1; // all or none are satisfied
    repeated string DropUniqueIds = 2; // drop intents with provided unique ids; suitable only for DeclareIntent command
}

message TReadIntent {
    // useful for synchronization of intents between CMS and BSC -- first CMS reads all the intents known to BSC,
    // then it deletes obsolete and creates new one
}

message TDropDonorDisk {
    NKikimrBlobStorage.TVSlotId VSlotId = 1;
    NKikimrBlobStorage.TVDiskID VDiskId = 2;
}

message TSetScrubPeriodicity {
    uint32 ScrubPeriodicity = 1; // in seconds; 0 = disable
}

message TAddDriveSerial {
    string Serial = 1;
    uint64 BoxId = 2;
    uint64 Kind = 3;
    EPDiskType PDiskType = 4; // default UNKNOWN type implies auto-detection of drive type
    NKikimrBlobStorage.TPDiskConfig PDiskConfig = 5;
}

// Remove drive if empty and delete PDisk, but leave row in table with LifeStage == REMOVED
message TRemoveDriveSerial {
    string Serial = 1;
}

// Remove drive if empty and delete PDisk, but totaly erase all drive-related info from BSC's internal database
message TForgetDriveSerial {
    string Serial = 1;
}

message TMigrateToSerial {
    TSerialManagementStage.E Stage = 1;
}

message TSetPDiskSpaceMarginPromille {
    uint32 PDiskSpaceMarginPromille = 1;
}

message TUpdateSettings {
    // each value may be specified either one time, or zero times; when it is specified, its value is written to State
    // and applied immediately; when no value specified, setting kept unchanged; if value is specified more than one
    // time, then last value is applied
    repeated uint32 DefaultMaxSlots = 1;
    repeated bool EnableSelfHeal = 2;
    repeated bool EnableDonorMode = 3;
    repeated uint64 ScrubPeriodicitySeconds = 4;
    repeated uint32 PDiskSpaceMarginPromille = 5;
    repeated uint32 GroupReserveMin = 6;
    repeated uint32 GroupReservePartPPM = 7;
    repeated uint32 MaxScrubbedDisksAtOnce = 8;
    repeated NKikimrBlobStorage.TPDiskSpaceColor.E PDiskSpaceColorBorder = 9;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// INTERFACE PART
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

message TConfigRequest {
    message TCommand {
        oneof Command {
            TDefineHostConfig DefineHostConfig = 1;
            TReadHostConfig ReadHostConfig = 2;
            TDeleteHostConfig DeleteHostConfig = 4;
            TDefineBox DefineBox = 5;
            TReadBox ReadBox = 6;
            TDeleteBox DeleteBox = 8;
            TDefineStoragePool DefineStoragePool = 9;
            TReadStoragePool ReadStoragePool = 10;
            TDeleteStoragePool DeleteStoragePool = 12;
            TUpdateDriveStatus UpdateDriveStatus = 13;
            TReadDriveStatus ReadDriveStatus = 14;
            TProposeStoragePools ProposeStoragePools = 15;
            TQueryBaseConfig QueryBaseConfig = 16; // introspection
            TMergeBoxes MergeBoxes = 23;
            TMoveGroups MoveGroups = 24; // move groups between storage pools; no checks of SP constraints are performed
            TAddMigrationPlan AddMigrationPlan = 25;
            TDeleteMigrationPlan DeleteMigrationPlan = 26;
            TEnableSelfHeal EnableSelfHeal = 27;
            TDeclareIntent DeclareIntent = 28;
            TReadIntent ReadIntent = 29;
            TEnableSelfHeal EnableDonorMode = 30;
            TDropDonorDisk DropDonorDisk = 31;
            TSetScrubPeriodicity SetScrubPeriodicity = 32;
            TAddDriveSerial AddDriveSerial = 33;
            TRemoveDriveSerial RemoveDriveSerial = 34;
            TForgetDriveSerial ForgetDriveSerial  = 36;
            TMigrateToSerial MigrateToSerial = 35;
            TSetPDiskSpaceMarginPromille SetPDiskSpaceMarginPromille = 37;
            TUpdateSettings UpdateSettings = 38;

            // commands intended for internal use
            TReassignGroupDisk ReassignGroupDisk = 19;
        }
    }

    // a set of commands to execute; NOTE that commands are executed one by one and only the single command execution
    // is atomic -- whe whole config request is split into several transactions with the provided commands and some of
    // auxiliary BS_CONTROLLER transactions
    repeated TCommand Command = 1;

    // if set to true, then transaction is terminated and nothing is committed; useful for dry-run
    bool Rollback = 2;

    // ignore group sanity checks when remapping disks
    bool IgnoreGroupSanityChecks = 3;

    // ignore group failure model checks
    bool IgnoreGroupFailModelChecks = 4;

    // ignore vslot sizes when remapping groups
    bool IgnoreVSlotQuotaCheck = 5;

    // allow unusable disks to stay in place when replacing others
    bool AllowUnusableDisks = 6;

    // ignore group reserve
    bool IgnoreGroupReserve = 7;

    // ignore degraded groups checking
    bool IgnoreDegradedGroupsChecks = 8;

    // do not settle slots over non-operating PDisks
    bool SettleOnlyOnOperationalDisks = 9;

    // execute this request ASAP
    bool Cito = 10;
}

enum ETriStateBool {
    kFalse = 0;
    kTrue = 1;
    kNotSet = 2;
}

message TBaseConfig {
    message TPDisk {
        uint32 NodeId = 1;
        uint32 PDiskId = 2;
        string Path = 3;
        EPDiskType Type = 4;
        ETriStateBool SharedWithOs = 5;
        ETriStateBool ReadCentric = 6;
        uint64 Kind = 7;
        TPDiskConfig PDiskConfig = 8;
        uint64 Guid = 9;
        uint64 BoxId = 10;
        uint32 NumStaticSlots = 11;
        EDriveStatus DriveStatus = 12;
        uint32 ExpectedSlotCount = 13;
        NKikimrBlobStorage.TPDiskMetrics PDiskMetrics = 14;
        uint64 DriveStatusChangeTimestamp = 15; // TInstant::GetValue()
    }
    message TVSlot {
        message TDonorDisk {
            NKikimrBlobStorage.TVDiskID VDiskId = 1;
            NKikimrBlobStorage.TVSlotId VSlotId = 2;
            NKikimrBlobStorage.TVDiskMetrics VDiskMetrics = 3;
        }

        NKikimrBlobStorage.TVSlotId VSlotId = 1;
        uint32 GroupId = 2;
        uint32 GroupGeneration = 3;
        string VDiskKind = 4;
        uint32 FailRealmIdx = 5;
        uint32 FailDomainIdx = 6;
        uint32 VDiskIdx = 7;
        uint64 AllocatedSize = 8;
        NKikimrBlobStorage.TVDiskMetrics VDiskMetrics = 9;
        string Status = 10; // textual representation of EVDiskStatus or empty string if status is not known/reported
        repeated TDonorDisk Donors = 11;
        bool Ready = 12; // is disk READY in terms of BSC (stable READY status for some period of time)
    }
    message TGroup {
        uint32 GroupId = 1;
        uint32 GroupGeneration = 2;
        string ErasureSpecies = 3;
        repeated NKikimrBlobStorage.TVSlotId VSlotId = 4;
        uint64 BoxId = 5;
        uint64 StoragePoolId = 6;
        bool SeenOperational = 7;
        TGroupStatus.E OperatingStatus = 8; // group status based on latest VDisk reports only
        TGroupStatus.E ExpectedStatus = 9; // status based not only on operational report, but on PDisk status and plans too
    }
    message TNode {
        uint32 NodeId = 1;
        bytes PhysicalLocation = 2 [deprecated=true];
        THostKey HostKey = 3;
        NActorsInterconnect.TNodeLocation Location = 4;
    }

    repeated TPDisk PDisk = 1;
    repeated TVSlot VSlot = 2;
    repeated TGroup Group = 3;
    repeated TNode Node = 4;
}

message TMoveCommand {
    uint32 GroupId = 1;
    uint32 OriginNodeId = 2;
    uint32 OriginPDiskId = 3;
    uint32 OriginVSlotId = 4;
    uint32 TargetNodeId = 5;
    uint32 TargetPDiskId = 6;
}

message TPDiskStat {
    uint32 NodeId = 1;
    uint32 PDiskId = 2;
    string Fqdn = 3;
    int32 IcPort = 4;
    string Path = 5;
    uint32 NumSlotsAfterMigration = 6;
}

message TReassignedItem {
    NKikimrBlobStorage.TVDiskID VDiskId = 1;
    NKikimrBlobStorage.TVSlotId From = 2;
    NKikimrBlobStorage.TVSlotId To = 3;
    string FromFqdn = 4;
    string FromPath = 5;
    string ToFqdn = 6;
    string ToPath = 7;
}

message TConfigResponse {
    message TStatus {
        enum EFailReason {
            kGeneric = 0;
            kHostNotFound = 1;
            kPDiskNotFound = 2;
            kHostConfigNotFound = 3;
            kItemConfigGenerationMismatch = 4;
            kMayLoseData = 5;
            kVDiskIdIncorrect = 6;
            kVSlotNotFound = 7;
            kDiskIsNotDonor = 8;
            kAlready = 9;
            kMayGetDegraded = 10;
        }

        message TFailParam {
            oneof Value {
                string Fqdn = 1;
                int32 IcPort = 2;
                uint32 NodeId = 3;
                uint32 PDiskId = 4;
                string Path = 5;
                uint64 HostConfigId = 6;
                uint64 BoxId = 7;
                uint64 StoragePoolId = 8;
                uint64 ItemConfigGenerationProvided = 9;
                uint64 ItemConfigGenerationExpected = 10;
                uint32 GroupId = 11;
                NKikimrBlobStorage.TVDiskID VDiskId = 12;
                NKikimrBlobStorage.TVSlotId VSlotId = 13;
            }
        }

        bool Success = 1;
        string ErrorDescription = 2;
        EFailReason FailReason = 12;
        repeated TFailParam FailParam = 13;
        repeated TDefineHostConfig HostConfig = 3;
        repeated TDefineBox Box = 4;
        repeated TUpdateDriveStatus DriveStatus = 5;
        repeated TDefineStoragePool StoragePool = 6;
        TBaseConfig BaseConfig = 7;
        repeated uint32 GroupId = 8;
        uint64 AssignedStoragePoolId = 9;
        repeated TMoveCommand MoveCommand = 10;
        repeated TPDiskStat PDiskStat = 11;
        repeated TReassignedItem ReassignedItem = 14;
        TDeclareIntent Intent = 15;
    }

    repeated TStatus Status = 1;
    bool Success = 2;
    string ErrorDescription = 3;
}