foundationdb/fdbclient/StorageServerInterface.h

639 lines
20 KiB
C
Raw Normal View History

2017-05-26 04:48:44 +08:00
/*
* StorageServerInterface.h
*
* This source file is part of the FoundationDB open source project
*
* Copyright 2013-2018 Apple Inc. and the FoundationDB project authors
*
2017-05-26 04:48:44 +08:00
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
2017-05-26 04:48:44 +08:00
* http://www.apache.org/licenses/LICENSE-2.0
*
2017-05-26 04:48:44 +08:00
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FDBCLIENT_STORAGESERVERINTERFACE_H
#define FDBCLIENT_STORAGESERVERINTERFACE_H
#pragma once
#include "fdbclient/FDBTypes.h"
2017-05-26 04:48:44 +08:00
#include "fdbrpc/Locality.h"
#include "fdbrpc/QueueModel.h"
#include "fdbrpc/fdbrpc.h"
#include "fdbrpc/LoadBalance.actor.h"
#include "fdbrpc/Stats.h"
#include "fdbrpc/TimedRequest.h"
#include "fdbclient/TagThrottle.h"
2017-05-26 04:48:44 +08:00
// Dead code, removed in the next protocol version
struct VersionReply {
constexpr static FileIdentifier file_identifier = 3;
Version version;
VersionReply() = default;
explicit VersionReply(Version version) : version(version) {}
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, version);
}
};
2017-05-26 04:48:44 +08:00
struct StorageServerInterface {
constexpr static FileIdentifier file_identifier = 15302073;
enum { BUSY_ALLOWED = 0, BUSY_FORCE = 1, BUSY_LOCAL = 2 };
2017-05-26 04:48:44 +08:00
enum { LocationAwareLoadBalance = 1 };
enum { AlwaysFresh = 0 };
2017-05-26 04:48:44 +08:00
LocalityData locality;
UID uniqueID;
RequestStream<struct GetValueRequest> getValue;
RequestStream<struct GetKeyRequest> getKey;
// Throws a wrong_shard_server if the keys in the request or result depend on data outside this server OR if a large
// selector offset prevents all data from being read in one range read
2017-05-26 04:48:44 +08:00
RequestStream<struct GetKeyValuesRequest> getKeyValues;
RequestStream<struct GetShardStateRequest> getShardState;
RequestStream<struct WaitMetricsRequest> waitMetrics;
RequestStream<struct SplitMetricsRequest> splitMetrics;
2019-07-26 07:27:32 +08:00
RequestStream<struct GetStorageMetricsRequest> getStorageMetrics;
2017-05-26 04:48:44 +08:00
RequestStream<ReplyPromise<Void>> waitFailure;
RequestStream<struct StorageQueuingMetricsRequest> getQueuingMetrics;
RequestStream<ReplyPromise<KeyValueStoreType>> getKeyValueStoreType;
RequestStream<struct WatchValueRequest> watchValue;
RequestStream<struct ReadHotSubRangeRequest> getReadHotRanges;
RequestStream<struct SplitRangeRequest> getRangeSplitPoints;
explicit StorageServerInterface(UID uid) : uniqueID(uid) {}
StorageServerInterface() : uniqueID(deterministicRandom()->randomUniqueID()) {}
NetworkAddress address() const { return getValue.getEndpoint().getPrimaryAddress(); }
2020-04-11 04:45:16 +08:00
NetworkAddress stableAddress() const { return getValue.getEndpoint().getStableAddress(); }
2020-03-13 01:18:53 +08:00
Optional<NetworkAddress> secondaryAddress() const { return getValue.getEndpoint().addresses.secondaryAddress; }
2017-05-26 04:48:44 +08:00
UID id() const { return uniqueID; }
std::string toString() const { return id().shortString(); }
template <class Ar>
2020-03-13 01:18:53 +08:00
void serialize(Ar& ar) {
// StorageServerInterface is persisted in the database, so changes here have to be versioned carefully!
// To change this serialization, ProtocolVersion::ServerListValue must be updated, and downgrades need to be
// considered
2017-05-26 04:48:44 +08:00
if (ar.protocolVersion().hasSmallEndpoints()) {
2020-06-12 09:35:48 +08:00
serializer(ar, uniqueID, locality, getValue);
if (Ar::isDeserializing) {
getKey = RequestStream<struct GetKeyRequest>(getValue.getEndpoint().getAdjustedEndpoint(1));
getKeyValues = RequestStream<struct GetKeyValuesRequest>(getValue.getEndpoint().getAdjustedEndpoint(2));
getShardState =
RequestStream<struct GetShardStateRequest>(getValue.getEndpoint().getAdjustedEndpoint(3));
waitMetrics = RequestStream<struct WaitMetricsRequest>(getValue.getEndpoint().getAdjustedEndpoint(4));
splitMetrics = RequestStream<struct SplitMetricsRequest>(getValue.getEndpoint().getAdjustedEndpoint(5));
getStorageMetrics =
RequestStream<struct GetStorageMetricsRequest>(getValue.getEndpoint().getAdjustedEndpoint(6));
waitFailure = RequestStream<ReplyPromise<Void>>(getValue.getEndpoint().getAdjustedEndpoint(7));
getQueuingMetrics =
RequestStream<struct StorageQueuingMetricsRequest>(getValue.getEndpoint().getAdjustedEndpoint(8));
getKeyValueStoreType =
RequestStream<ReplyPromise<KeyValueStoreType>>(getValue.getEndpoint().getAdjustedEndpoint(9));
watchValue = RequestStream<struct WatchValueRequest>(getValue.getEndpoint().getAdjustedEndpoint(10));
getReadHotRanges =
RequestStream<struct ReadHotSubRangeRequest>(getValue.getEndpoint().getAdjustedEndpoint(11));
getRangeSplitPoints =
RequestStream<struct SplitRangeRequest>(getValue.getEndpoint().getAdjustedEndpoint(12));
}
2019-01-29 11:38:13 +08:00
} else {
ASSERT(Ar::isDeserializing);
if constexpr (is_fb_function<Ar>) {
ASSERT(false);
}
serializer(ar,
uniqueID,
locality,
getValue,
getKey,
getKeyValues,
getShardState,
waitMetrics,
splitMetrics,
getStorageMetrics,
waitFailure,
getQueuingMetrics,
getKeyValueStoreType);
if (ar.protocolVersion().hasWatches())
serializer(ar, watchValue);
2019-01-29 11:38:13 +08:00
}
2017-05-26 04:48:44 +08:00
}
bool operator==(StorageServerInterface const& s) const { return uniqueID == s.uniqueID; }
bool operator<(StorageServerInterface const& s) const { return uniqueID < s.uniqueID; }
2017-05-26 04:48:44 +08:00
void initEndpoints() {
std::vector<std::pair<FlowReceiver*, TaskPriority>> streams;
streams.push_back(getValue.getReceiver(TaskPriority::LoadBalancedEndpoint));
streams.push_back(getKey.getReceiver(TaskPriority::LoadBalancedEndpoint));
streams.push_back(getKeyValues.getReceiver(TaskPriority::LoadBalancedEndpoint));
streams.push_back(getShardState.getReceiver());
streams.push_back(waitMetrics.getReceiver());
streams.push_back(splitMetrics.getReceiver());
streams.push_back(getStorageMetrics.getReceiver());
streams.push_back(waitFailure.getReceiver());
streams.push_back(getQueuingMetrics.getReceiver());
streams.push_back(getKeyValueStoreType.getReceiver());
streams.push_back(watchValue.getReceiver());
streams.push_back(getReadHotRanges.getReceiver());
streams.push_back(getRangeSplitPoints.getReceiver());
2020-05-20 06:35:57 +08:00
FlowTransport::transport().addEndpoints(streams);
2017-05-26 04:48:44 +08:00
}
};
struct StorageInfo : NonCopyable, public ReferenceCounted<StorageInfo> {
Tag tag;
StorageServerInterface interf;
StorageInfo() : tag(invalidTag) {}
};
struct ServerCacheInfo {
std::vector<Tag> tags; // all tags in both primary and remote DC for the key-range
std::vector<Reference<StorageInfo>> src_info;
std::vector<Reference<StorageInfo>> dest_info;
void populateTags() {
if (tags.size())
return;
for (const auto& info : src_info) {
tags.push_back(info->tag);
}
for (const auto& info : dest_info) {
tags.push_back(info->tag);
}
uniquify(tags);
}
};
2017-05-26 04:48:44 +08:00
struct GetValueReply : public LoadBalancedReply {
constexpr static FileIdentifier file_identifier = 1378929;
2017-05-26 04:48:44 +08:00
Optional<Value> value;
bool cached;
2017-05-26 04:48:44 +08:00
GetValueReply() : cached(false) {}
GetValueReply(Optional<Value> value, bool cached) : value(value), cached(cached) {}
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
2020-01-27 12:56:59 +08:00
serializer(ar, LoadBalancedReply::penalty, LoadBalancedReply::error, value, cached);
2017-05-26 04:48:44 +08:00
}
};
struct GetValueRequest : TimedRequest {
constexpr static FileIdentifier file_identifier = 8454530;
SpanID spanContext;
2017-05-26 04:48:44 +08:00
Key key;
Version version;
Optional<TagSet> tags;
2017-05-26 04:48:44 +08:00
Optional<UID> debugID;
ReplyPromise<GetValueReply> reply;
GetValueRequest() {}
GetValueRequest(SpanID spanContext, const Key& key, Version ver, Optional<TagSet> tags, Optional<UID> debugID)
: spanContext(spanContext), key(key), version(ver), tags(tags), debugID(debugID) {}
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, key, version, tags, debugID, reply, spanContext);
2017-05-26 04:48:44 +08:00
}
};
struct WatchValueReply {
constexpr static FileIdentifier file_identifier = 3;
Version version;
2020-01-27 12:56:59 +08:00
bool cached = false;
WatchValueReply() = default;
explicit WatchValueReply(Version version) : version(version) {}
template <class Ar>
void serialize(Ar& ar) {
2020-01-27 12:56:59 +08:00
serializer(ar, version, cached);
}
};
2017-05-26 04:48:44 +08:00
struct WatchValueRequest {
constexpr static FileIdentifier file_identifier = 14747733;
SpanID spanContext;
2017-05-26 04:48:44 +08:00
Key key;
Optional<Value> value;
Version version;
Optional<TagSet> tags;
2017-05-26 04:48:44 +08:00
Optional<UID> debugID;
ReplyPromise<WatchValueReply> reply;
WatchValueRequest() {}
WatchValueRequest(SpanID spanContext,
const Key& key,
Optional<Value> value,
Version ver,
Optional<TagSet> tags,
Optional<UID> debugID)
: spanContext(spanContext), key(key), value(value), version(ver), tags(tags), debugID(debugID) {}
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, key, value, version, tags, debugID, reply, spanContext);
2017-05-26 04:48:44 +08:00
}
};
struct GetKeyValuesReply : public LoadBalancedReply {
constexpr static FileIdentifier file_identifier = 1783066;
2017-05-26 04:48:44 +08:00
Arena arena;
VectorRef<KeyValueRef, VecSerStrategy::String> data;
2017-05-26 04:48:44 +08:00
Version version; // useful when latestVersion was requested
bool more;
2020-01-27 12:56:59 +08:00
bool cached = false;
2017-05-26 04:48:44 +08:00
2019-11-13 05:01:29 +08:00
GetKeyValuesReply() : version(invalidVersion), more(false), cached(false) {}
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
2020-01-27 12:56:59 +08:00
serializer(ar, LoadBalancedReply::penalty, LoadBalancedReply::error, data, version, more, cached, arena);
2017-05-26 04:48:44 +08:00
}
};
struct GetKeyValuesRequest : TimedRequest {
constexpr static FileIdentifier file_identifier = 6795746;
SpanID spanContext;
2017-05-26 04:48:44 +08:00
Arena arena;
KeySelectorRef begin, end;
Version version; // or latestVersion
2017-05-26 04:48:44 +08:00
int limit, limitBytes;
bool isFetchKeys;
Optional<TagSet> tags;
2017-05-26 04:48:44 +08:00
Optional<UID> debugID;
ReplyPromise<GetKeyValuesReply> reply;
GetKeyValuesRequest() : isFetchKeys(false) {}
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, begin, end, version, limit, limitBytes, isFetchKeys, tags, debugID, reply, spanContext, arena);
2017-05-26 04:48:44 +08:00
}
};
struct GetKeyReply : public LoadBalancedReply {
constexpr static FileIdentifier file_identifier = 11226513;
2017-05-26 04:48:44 +08:00
KeySelector sel;
bool cached;
2017-05-26 04:48:44 +08:00
GetKeyReply() : cached(false) {}
GetKeyReply(KeySelector sel, bool cached) : sel(sel), cached(cached) {}
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
2020-01-27 12:56:59 +08:00
serializer(ar, LoadBalancedReply::penalty, LoadBalancedReply::error, sel, cached);
2017-05-26 04:48:44 +08:00
}
};
struct GetKeyRequest : TimedRequest {
constexpr static FileIdentifier file_identifier = 10457870;
SpanID spanContext;
2017-05-26 04:48:44 +08:00
Arena arena;
KeySelectorRef sel;
Version version; // or latestVersion
Optional<TagSet> tags;
Optional<UID> debugID;
2017-05-26 04:48:44 +08:00
ReplyPromise<GetKeyReply> reply;
GetKeyRequest() {}
GetKeyRequest(SpanID spanContext,
KeySelectorRef const& sel,
Version version,
Optional<TagSet> tags,
Optional<UID> debugID)
: spanContext(spanContext), sel(sel), version(version), debugID(debugID) {}
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, sel, version, tags, debugID, reply, spanContext, arena);
2017-05-26 04:48:44 +08:00
}
};
struct GetShardStateReply {
constexpr static FileIdentifier file_identifier = 0;
Version first;
Version second;
GetShardStateReply() = default;
GetShardStateReply(Version first, Version second) : first(first), second(second) {}
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, first, second);
}
};
2017-05-26 04:48:44 +08:00
struct GetShardStateRequest {
constexpr static FileIdentifier file_identifier = 15860168;
enum waitMode { NO_WAIT = 0, FETCHING = 1, READABLE = 2 };
2017-05-26 04:48:44 +08:00
KeyRange keys;
int32_t mode;
ReplyPromise<GetShardStateReply> reply;
2017-05-26 04:48:44 +08:00
GetShardStateRequest() {}
GetShardStateRequest(KeyRange const& keys, waitMode mode) : keys(keys), mode(mode) {}
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, keys, mode, reply);
2017-05-26 04:48:44 +08:00
}
};
struct StorageMetrics {
constexpr static FileIdentifier file_identifier = 13622226;
int64_t bytes = 0; // total storage
// FIXME: currently, neither of bytesPerKSecond or iosPerKSecond are actually used in DataDistribution calculations.
// This may change in the future, but this comment is left here to avoid any confusion for the time being.
int64_t bytesPerKSecond = 0; // network bandwidth (average over 10s)
int64_t iosPerKSecond = 0;
int64_t bytesReadPerKSecond = 0;
2017-05-26 04:48:44 +08:00
static const int64_t infinity = 1LL << 60;
2017-05-26 04:48:44 +08:00
bool allLessOrEqual(const StorageMetrics& rhs) const {
return bytes <= rhs.bytes && bytesPerKSecond <= rhs.bytesPerKSecond && iosPerKSecond <= rhs.iosPerKSecond &&
bytesReadPerKSecond <= rhs.bytesReadPerKSecond;
2017-05-26 04:48:44 +08:00
}
void operator+=(const StorageMetrics& rhs) {
2017-05-26 04:48:44 +08:00
bytes += rhs.bytes;
bytesPerKSecond += rhs.bytesPerKSecond;
iosPerKSecond += rhs.iosPerKSecond;
bytesReadPerKSecond += rhs.bytesReadPerKSecond;
2017-05-26 04:48:44 +08:00
}
void operator-=(const StorageMetrics& rhs) {
2017-05-26 04:48:44 +08:00
bytes -= rhs.bytes;
bytesPerKSecond -= rhs.bytesPerKSecond;
iosPerKSecond -= rhs.iosPerKSecond;
bytesReadPerKSecond -= rhs.bytesReadPerKSecond;
2017-05-26 04:48:44 +08:00
}
template <class F>
void operator*=(F f) {
2017-05-26 04:48:44 +08:00
bytes *= f;
bytesPerKSecond *= f;
iosPerKSecond *= f;
bytesReadPerKSecond *= f;
2017-05-26 04:48:44 +08:00
}
bool allZero() const { return !bytes && !bytesPerKSecond && !iosPerKSecond && !bytesReadPerKSecond; }
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, bytes, bytesPerKSecond, iosPerKSecond, bytesReadPerKSecond);
2017-05-26 04:48:44 +08:00
}
void negate() { operator*=(-1.0); }
StorageMetrics operator-() const {
StorageMetrics x(*this);
x.negate();
return x;
}
StorageMetrics operator+(const StorageMetrics& r) const {
StorageMetrics x(*this);
x += r;
return x;
}
StorageMetrics operator-(const StorageMetrics& r) const {
StorageMetrics x(r);
x.negate();
x += *this;
return x;
}
template <class F>
StorageMetrics operator*(F f) const {
StorageMetrics x(*this);
x *= f;
return x;
}
2017-05-26 04:48:44 +08:00
bool operator==(StorageMetrics const& rhs) const {
return bytes == rhs.bytes && bytesPerKSecond == rhs.bytesPerKSecond && iosPerKSecond == rhs.iosPerKSecond &&
bytesReadPerKSecond == rhs.bytesReadPerKSecond;
2017-05-26 04:48:44 +08:00
}
std::string toString() const {
return format("Bytes: %lld, BPerKSec: %lld, iosPerKSec: %lld, BReadPerKSec: %lld",
bytes,
bytesPerKSecond,
iosPerKSecond,
bytesReadPerKSecond);
2017-05-26 04:48:44 +08:00
}
};
struct WaitMetricsRequest {
// Waits for any of the given minimum or maximum metrics to be exceeded, and then returns the current values
// Send a reversed range for min, max to receive an immediate report
constexpr static FileIdentifier file_identifier = 1795961;
2017-05-26 04:48:44 +08:00
Arena arena;
KeyRangeRef keys;
StorageMetrics min, max;
ReplyPromise<StorageMetrics> reply;
WaitMetricsRequest() {}
WaitMetricsRequest(KeyRangeRef const& keys, StorageMetrics const& min, StorageMetrics const& max)
: keys(arena, keys), min(min), max(max) {}
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, keys, min, max, reply, arena);
2017-05-26 04:48:44 +08:00
}
};
struct SplitMetricsReply {
constexpr static FileIdentifier file_identifier = 11530792;
2017-05-26 04:48:44 +08:00
Standalone<VectorRef<KeyRef>> splits;
StorageMetrics used;
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, splits, used);
2017-05-26 04:48:44 +08:00
}
};
struct SplitMetricsRequest {
constexpr static FileIdentifier file_identifier = 10463876;
2017-05-26 04:48:44 +08:00
Arena arena;
KeyRangeRef keys;
StorageMetrics limits;
StorageMetrics used;
StorageMetrics estimated;
bool isLastShard;
ReplyPromise<SplitMetricsReply> reply;
SplitMetricsRequest() {}
SplitMetricsRequest(KeyRangeRef const& keys,
StorageMetrics const& limits,
StorageMetrics const& used,
StorageMetrics const& estimated,
bool isLastShard)
: keys(arena, keys), limits(limits), used(used), estimated(estimated), isLastShard(isLastShard) {}
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, keys, limits, used, estimated, isLastShard, reply, arena);
2017-05-26 04:48:44 +08:00
}
};
// Should always be used inside a `Standalone`.
struct ReadHotRangeWithMetrics {
KeyRangeRef keys;
2021-02-05 08:20:18 +08:00
// density refers to the ratio of bytes sent(because of the read) and bytes on disk.
2021-02-05 09:31:05 +08:00
// For example if key range [A, B) and [B, C) respectively has byte size 100 bytes on disk.
// Key range [A,B) was read 30 times.
// The density for key range [A,C) is 30 * 100 / 200 = 15
double density;
2021-02-05 08:20:18 +08:00
// How many bytes of data was sent in a period of time because of read requests.
double readBandwidth;
ReadHotRangeWithMetrics() = default;
ReadHotRangeWithMetrics(KeyRangeRef const& keys, double density, double readBandwidth)
: keys(keys), density(density), readBandwidth(readBandwidth) {}
ReadHotRangeWithMetrics(Arena& arena, const ReadHotRangeWithMetrics& rhs)
: keys(arena, rhs.keys), density(rhs.density), readBandwidth(rhs.readBandwidth) {}
2020-12-27 06:30:44 +08:00
int expectedSize() const { return keys.expectedSize() + sizeof(density) + sizeof(readBandwidth); }
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, keys, density, readBandwidth);
}
};
struct ReadHotSubRangeReply {
constexpr static FileIdentifier file_identifier = 10424537;
Standalone<VectorRef<ReadHotRangeWithMetrics>> readHotRanges;
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, readHotRanges);
}
};
struct ReadHotSubRangeRequest {
constexpr static FileIdentifier file_identifier = 10259266;
Arena arena;
KeyRangeRef keys;
ReplyPromise<ReadHotSubRangeReply> reply;
ReadHotSubRangeRequest() {}
ReadHotSubRangeRequest(KeyRangeRef const& keys) : keys(arena, keys) {}
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, keys, reply, arena);
}
};
struct SplitRangeReply {
2020-08-08 05:03:42 +08:00
constexpr static FileIdentifier file_identifier = 11813134;
// If the given range can be divided, contains the split points.
// If the given range cannot be divided(for exmaple its total size is smaller than the chunk size), this would be
// empty
Standalone<VectorRef<KeyRef>> splitPoints;
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, splitPoints);
}
};
struct SplitRangeRequest {
2020-08-08 05:03:42 +08:00
constexpr static FileIdentifier file_identifier = 10725174;
Arena arena;
KeyRangeRef keys;
int64_t chunkSize;
ReplyPromise<SplitRangeReply> reply;
SplitRangeRequest() {}
SplitRangeRequest(KeyRangeRef const& keys, int64_t chunkSize) : keys(arena, keys), chunkSize(chunkSize) {}
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, keys, chunkSize, reply, arena);
}
};
2019-07-26 07:27:32 +08:00
struct GetStorageMetricsReply {
constexpr static FileIdentifier file_identifier = 15491478;
2017-05-26 04:48:44 +08:00
StorageMetrics load;
StorageMetrics available;
2017-05-26 04:48:44 +08:00
StorageMetrics capacity;
2019-07-26 07:27:32 +08:00
double bytesInputRate;
int64_t versionLag;
double lastUpdate;
2019-07-26 07:27:32 +08:00
GetStorageMetricsReply() : bytesInputRate(0) {}
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, load, available, capacity, bytesInputRate, versionLag, lastUpdate);
2017-05-26 04:48:44 +08:00
}
};
2019-07-26 07:27:32 +08:00
struct GetStorageMetricsRequest {
constexpr static FileIdentifier file_identifier = 13290999;
2019-07-26 07:27:32 +08:00
ReplyPromise<GetStorageMetricsReply> reply;
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, reply);
2017-05-26 04:48:44 +08:00
}
};
struct StorageQueuingMetricsReply {
constexpr static FileIdentifier file_identifier = 7633366;
2017-05-26 04:48:44 +08:00
double localTime;
int64_t instanceID; // changes if bytesDurable and bytesInput reset
2017-05-26 04:48:44 +08:00
int64_t bytesDurable, bytesInput;
StorageBytes storageBytes;
Version version; // current storage server version
Version durableVersion; // latest version durable on storage server
double cpuUsage;
double diskUsage;
2019-03-02 05:14:18 +08:00
double localRateLimit;
Optional<TransactionTag> busiestTag;
double busiestTagFractionalBusyness;
double busiestTagRate;
2017-05-26 04:48:44 +08:00
template <class Ar>
void serialize(Ar& ar) {
serializer(ar,
localTime,
instanceID,
bytesDurable,
bytesInput,
version,
storageBytes,
durableVersion,
cpuUsage,
diskUsage,
localRateLimit,
busiestTag,
busiestTagFractionalBusyness,
busiestTagRate);
2017-05-26 04:48:44 +08:00
}
};
2019-04-17 06:00:12 +08:00
struct StorageQueuingMetricsRequest {
// SOMEDAY: Send threshold value to avoid polling faster than the information changes?
constexpr static FileIdentifier file_identifier = 3978640;
ReplyPromise<struct StorageQueuingMetricsReply> reply;
template <class Ar>
void serialize(Ar& ar) {
serializer(ar, reply);
}
};
2017-05-26 04:48:44 +08:00
#endif